using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Linq.Expressions;
|
using NUnit.Framework;
|
|
namespace DynamicExpresso.UnitTest
|
{
|
[TestFixture]
|
public class OtherTests
|
{
|
[Test]
|
public void Space_Characters_Are_Ignored()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval(" 45\t\t + 1 \r \n"), Is.EqualTo(46));
|
}
|
|
[Test]
|
public void Empty_Null_Withespace_Expression()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval(""), Is.Null);
|
Assert.That(target.Parse("").ReturnType, Is.EqualTo(typeof(void)));
|
|
Assert.That(target.Eval(null), Is.Null);
|
Assert.That(target.Parse(null).ReturnType, Is.EqualTo(typeof(void)));
|
|
Assert.That(target.Eval(" \t\t\r\n \t "), Is.Null);
|
Assert.That(target.Parse(" \t\t\r\n \t ").ReturnType, Is.EqualTo(typeof(void)));
|
}
|
|
[Test]
|
public void Complex_expression()
|
{
|
var target = new Interpreter();
|
|
var x = new MyTestService();
|
var y = 5;
|
var parameters = new[] {
|
new Parameter("x", x.GetType(), x),
|
new Parameter("y", y.GetType(), y),
|
};
|
|
Assert.That(target.Eval("x.AProperty >\t y && \r\n x.HelloWorld().Length == 10", parameters), Is.EqualTo(x.AProperty > y && x.HelloWorld().Length == 10));
|
Assert.That(target.Eval("x.AProperty * (4 + 65) / x.AProperty", parameters), Is.EqualTo(x.AProperty * (4 + 65) / x.AProperty));
|
|
Assert.That(target.Eval("Convert.ToString(x.AProperty * (4 + 65) / x.AProperty)", parameters), Is.EqualTo(Convert.ToString(x.AProperty * (4 + 65) / x.AProperty)));
|
}
|
|
[Test]
|
public void Parse_An_Expression_And_Invoke_It_With_Different_Parameters()
|
{
|
var service = new MyTestService();
|
|
var target = new Interpreter()
|
.SetVariable("service", service);
|
|
var func = target.Parse("x > 4 ? service.VoidMethod() : service.VoidMethod2()",
|
new Parameter("x", typeof(int)));
|
|
Assert.That(func.ReturnType, Is.EqualTo(typeof(void)));
|
|
Assert.That(service.VoidMethodCalled, Is.EqualTo(0));
|
Assert.That(service.VoidMethod2Called, Is.EqualTo(0));
|
|
func.Invoke(new Parameter("x", 5));
|
Assert.That(service.VoidMethodCalled, Is.EqualTo(1));
|
Assert.That(service.VoidMethod2Called, Is.EqualTo(0));
|
|
func.Invoke(new Parameter("x", 2));
|
Assert.That(service.VoidMethodCalled, Is.EqualTo(1));
|
Assert.That(service.VoidMethod2Called, Is.EqualTo(1));
|
}
|
|
[Test]
|
public void Should_Understand_ReturnType_Of_expressions()
|
{
|
var target = new Interpreter();
|
|
var x = new MyTestService();
|
var y = 5;
|
var parameters = new[] {
|
new Parameter("x", x.GetType(), x),
|
new Parameter("y", y.GetType(), y),
|
};
|
|
Assert.That(target.Parse("x.AProperty > y && x.HelloWorld().Length == 10", parameters).ReturnType, Is.EqualTo(typeof(bool)));
|
Assert.That(target.Parse("x.AProperty * (4 + 65) / x.AProperty", parameters).ReturnType, Is.EqualTo(typeof(int)));
|
}
|
|
[Test]
|
public void Execute_the_same_function_multiple_times()
|
{
|
var target = new Interpreter();
|
|
var functionX = target.Parse("Math.Pow(x, y) + 5",
|
new Parameter("x", typeof(double)),
|
new Parameter("y", typeof(double)));
|
|
Assert.That(functionX.Invoke(15, 12), Is.EqualTo(Math.Pow(15, 12) + 5));
|
Assert.That(functionX.Invoke(5, 1), Is.EqualTo(Math.Pow(5, 1) + 5));
|
Assert.That(functionX.Invoke(11, 8), Is.EqualTo(Math.Pow(11, 8) + 5));
|
Assert.That(functionX.Invoke(new Parameter("x", 3.0),
|
new Parameter("y", 4.0)), Is.EqualTo(Math.Pow(3, 4) + 5));
|
Assert.That(functionX.Invoke(new Parameter("x", 9.0),
|
new Parameter("y", 2.0)), Is.EqualTo(Math.Pow(9, 2) + 5));
|
Assert.That(functionX.Invoke(new Parameter("x", 1.0),
|
new Parameter("y", 3.0)), Is.EqualTo(Math.Pow(1, 3) + 5));
|
}
|
|
[Test]
|
public void Linq_Where()
|
{
|
var customers = new List<Customer> {
|
new Customer() { Name = "David", Age = 31, Gender = 'M' },
|
new Customer() { Name = "Mary", Age = 29, Gender = 'F' },
|
new Customer() { Name = "Jack", Age = 2, Gender = 'M' },
|
new Customer() { Name = "Marta", Age = 1, Gender = 'F' },
|
new Customer() { Name = "Moses", Age = 120, Gender = 'M' },
|
};
|
|
string whereExpression = "customer.Age > 18 && customer.Gender == 'F'";
|
|
var interpreter = new Interpreter();
|
Func<Customer, bool> dynamicWhere = interpreter.ParseAsDelegate<Func<Customer, bool>>(whereExpression, "customer");
|
|
Assert.That(customers.Where(dynamicWhere).Count(), Is.EqualTo(1));
|
}
|
|
[Test]
|
public void Linq_Where2()
|
{
|
var prices = new[] { 5, 8, 6, 2 };
|
|
var whereFunction = new Interpreter()
|
.ParseAsDelegate<Func<int, bool>>("arg > 5");
|
|
Assert.That(prices.Where(whereFunction).Count(), Is.EqualTo(2));
|
}
|
|
[Test]
|
public void Linq_Queryable_Expression_Where()
|
{
|
IQueryable<Customer> customers = (new List<Customer> {
|
new Customer() { Name = "David", Age = 31, Gender = 'M' },
|
new Customer() { Name = "Mary", Age = 29, Gender = 'F' },
|
new Customer() { Name = "Jack", Age = 2, Gender = 'M' },
|
new Customer() { Name = "Marta", Age = 1, Gender = 'F' },
|
new Customer() { Name = "Moses", Age = 120, Gender = 'M' },
|
}).AsQueryable();
|
|
string whereExpression = "customer.Age > 18 && customer.Gender == 'F'";
|
|
var interpreter = new Interpreter();
|
Expression<Func<Customer, bool>> expression = interpreter.ParseAsExpression<Func<Customer, bool>>(whereExpression, "customer");
|
|
Assert.That(customers.Where(expression).Count(), Is.EqualTo(1));
|
}
|
|
[Test]
|
public void Multiple_Parentheses_Math_Expression()
|
{
|
var interpreter = new Interpreter();
|
|
Assert.That(interpreter.Eval("2 + ((1 + 5) * (2 - 1))"), Is.EqualTo(2 + ((1 + 5) * (2 - 1))));
|
Assert.That(interpreter.Eval("2 + ((((1 + 5))) * (((2 - 1))+5.5))"), Is.EqualTo(2 + ((((1 + 5))) * (((2 - 1)) + 5.5))));
|
}
|
|
[Test]
|
public void Multiple_Parentheses_Cast_Expression()
|
{
|
var interpreter = new Interpreter();
|
|
Assert.That(interpreter.Eval("((double)5).GetType().Name"), Is.EqualTo(((double)5).GetType().Name));
|
}
|
|
private class MyTestService
|
{
|
public DateTime AField = DateTime.Now;
|
public DateTime AFIELD = DateTime.UtcNow;
|
|
public int AProperty
|
{
|
get { return 769; }
|
}
|
|
public int APROPERTY
|
{
|
get { return 887; }
|
}
|
|
public string HelloWorld()
|
{
|
return "Ciao mondo";
|
}
|
|
public string HELLOWORLD()
|
{
|
return "HELLO";
|
}
|
|
public int VoidMethodCalled { get; set; }
|
public void VoidMethod()
|
{
|
System.Diagnostics.Debug.WriteLine("VoidMethod called");
|
VoidMethodCalled++;
|
}
|
|
public int VoidMethod2Called { get; set; }
|
public void VoidMethod2()
|
{
|
System.Diagnostics.Debug.WriteLine("VoidMethod2 called");
|
VoidMethod2Called++;
|
}
|
}
|
|
private class Customer
|
{
|
public string Name { get; set; }
|
public int Age { get; set; }
|
public char Gender { get; set; }
|
}
|
}
|
}
|
