using System;
|
using NUnit.Framework;
|
using System.Globalization;
|
using System.Reflection;
|
using System.Linq;
|
|
namespace DynamicExpresso.UnitTest
|
{
|
[TestFixture]
|
public class ParametersTest
|
{
|
[Test]
|
public void Basic_parameters()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[] {
|
new Parameter("x", 23),
|
new Parameter("y", 7)
|
};
|
|
Assert.That(target.Eval("x + y", parameters), Is.EqualTo(30));
|
}
|
|
[Test]
|
public void Parameters_orders_is_not_important_for_eval()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[] {
|
new Parameter("B", "B"),
|
new Parameter("A", "A"),
|
};
|
|
Assert.That(target.Eval("A + B", parameters), Is.EqualTo("AB"));
|
}
|
|
[Test]
|
public void Parameters_orders_can_be_different_between_parse_and_invoke()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[] {
|
new Parameter("A", "A"),
|
new Parameter("B", "B"),
|
};
|
|
var lambda = target.Parse("A + B", parameters);
|
|
Assert.That(lambda.Invoke(parameters.Reverse()), Is.EqualTo("AB"));
|
}
|
|
[Test]
|
public void Expression_Without_Parameters()
|
{
|
var target = new Interpreter();
|
|
var parameters = new Parameter[0];
|
|
var exp = target.Parse("10+5", parameters);
|
|
Assert.That(exp.Invoke(), Is.EqualTo(15));
|
}
|
|
[Test]
|
public void Parameters_Mismatch()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[] {
|
new Parameter("x", 23),
|
new Parameter("y", 7)
|
};
|
|
var exp = target.Parse("x + y", parameters);
|
|
var parametersMismatch = new[] {
|
new Parameter("x", 546)
|
};
|
|
Assert.Throws<TargetParameterCountException>(() => exp.Invoke(parametersMismatch));
|
}
|
|
[Test]
|
public void Invoke_the_lambda_using_different_parameters_values()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[] {
|
new Parameter("x", typeof(int)),
|
new Parameter("y", typeof(int))
|
};
|
|
var myFunc = target.Parse("x + y", parameters);
|
|
var parameters1 = new[] {
|
new Parameter("x", 25),
|
new Parameter("y", 5)
|
};
|
|
Assert.That(myFunc.Invoke(parameters1), Is.EqualTo(30));
|
|
var parameters2 = new[] {
|
new Parameter("x", 60),
|
new Parameter("y", -2)
|
};
|
|
Assert.That(myFunc.Invoke(parameters2), Is.EqualTo(58));
|
}
|
|
[Test]
|
public void Different_parameters_values_With_Args()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[] {
|
new Parameter("x", typeof(int)),
|
new Parameter("y", typeof(int))
|
};
|
|
var myFunc = target.Parse("x + y", parameters);
|
|
Assert.That(myFunc.Invoke(23, 7), Is.EqualTo(30));
|
Assert.That(myFunc.Invoke(32, -2), Is.EqualTo(30));
|
}
|
|
[Test]
|
public void Primitive_parameters()
|
{
|
var target = new Interpreter();
|
|
double x = 2;
|
string y = "param y";
|
var parameters = new[] {
|
new Parameter("x", x.GetType(), x),
|
new Parameter("y", y.GetType(), y)
|
};
|
|
Assert.That(target.Eval("x", parameters), Is.EqualTo(x));
|
Assert.That(target.Eval("x+x+x", parameters), Is.EqualTo(x + x + x));
|
Assert.That(target.Eval("x * x", parameters), Is.EqualTo(x * x));
|
Assert.That(target.Eval("y", parameters), Is.EqualTo(y));
|
Assert.That(target.Eval("y.Length + x", parameters), Is.EqualTo(y.Length + x));
|
}
|
|
[Test]
|
public void Parameters_by_default_Are_Case_Sensitive()
|
{
|
var target = new Interpreter();
|
|
double x = 2;
|
string X = "param y";
|
var parameters = new[] {
|
new Parameter("x", x.GetType(), x),
|
new Parameter("X", X.GetType(), X)
|
};
|
|
Assert.That(target.Eval("x", parameters), Is.EqualTo(x));
|
Assert.That(target.Eval("X", parameters), Is.EqualTo(X));
|
}
|
|
[Test]
|
public void Parameters_can_be_Case_insensitive()
|
{
|
var target = new Interpreter(InterpreterOptions.DefaultCaseInsensitive);
|
|
double x = 2;
|
var parameters = new[] {
|
new Parameter("x", x.GetType(), x)
|
};
|
|
Assert.That(target.Eval("x", parameters), Is.EqualTo(x));
|
Assert.That(target.Eval("X", parameters), Is.EqualTo(x));
|
}
|
|
[Test]
|
public void Parameters_cannot_be_parsed_with_one_case_and_invoked_in_another_case()
|
{
|
var target = new Interpreter();
|
|
double x = 2;
|
|
var lambda = target.Parse("x", new Parameter("x", x.GetType()));
|
|
Assert.Throws<TargetParameterCountException>(() => lambda.Invoke(new Parameter("X", x)));
|
}
|
|
[Test]
|
public void Parameters_can_be_parsed_with_one_case_and_invoked_in_another_case_with_case_insensitive_option()
|
{
|
var target = new Interpreter(InterpreterOptions.DefaultCaseInsensitive);
|
|
double x = 2;
|
|
var lambda = target.Parse("x", new Parameter("x", x.GetType()));
|
|
Assert.That(lambda.Invoke(new Parameter("X", x)), Is.EqualTo(x));
|
}
|
|
[Test]
|
public void Complex_parameters()
|
{
|
var target = new Interpreter();
|
|
var x = new MyTestService();
|
var y = new Uri("http://www.google.com");
|
var z = CultureInfo.GetCultureInfo("en-US");
|
var parameters = new[] {
|
new Parameter("x", x.GetType(), x),
|
new Parameter("y", y.GetType(), y),
|
new Parameter("z", z.GetType(), z)
|
};
|
|
Assert.That(target.Eval("x", parameters), Is.EqualTo(x));
|
Assert.That(target.Eval("y", parameters), Is.EqualTo(y));
|
Assert.That(target.Eval("z", parameters), Is.EqualTo(z));
|
}
|
|
[Test]
|
public void Methods_Fields_and_Properties_On_Parameters()
|
{
|
var target = new Interpreter();
|
|
var x = new MyTestService();
|
var y = "davide";
|
var z = 5;
|
var w = DateTime.Today;
|
var parameters = new[] {
|
new Parameter("x", x.GetType(), x),
|
new Parameter("y", y.GetType(), y),
|
new Parameter("z", z.GetType(), z),
|
new Parameter("w", w.GetType(), w)
|
};
|
|
Assert.That(target.Eval("x.HelloWorld()", parameters), Is.EqualTo(x.HelloWorld()));
|
Assert.That(target.Eval("x.CallMethod( y, z,w)", parameters), Is.EqualTo(x.CallMethod(y, z, w)));
|
Assert.That(target.Eval("x.AProperty + 1", parameters), Is.EqualTo(x.AProperty + 1));
|
Assert.That(target.Eval("x.AField", parameters), Is.EqualTo(x.AField));
|
}
|
|
[Test]
|
public void Nullable_as_parameters()
|
{
|
var target = new Interpreter();
|
|
int? x;
|
x = 39;
|
int? y;
|
y = null;
|
|
var parameters = new[] {
|
new Parameter("x", typeof(int?), x),
|
new Parameter("y", typeof(int?), y)
|
};
|
|
Assert.That(target.Eval("x", parameters), Is.EqualTo(x));
|
Assert.That(target.Eval("y", parameters), Is.EqualTo(y));
|
Assert.That(target.Eval("x.HasValue", parameters), Is.EqualTo(x.HasValue));
|
Assert.That(target.Eval("y.HasValue", parameters), Is.EqualTo(y.HasValue));
|
}
|
|
[Test]
|
public void Delegates_as_parameters()
|
{
|
var target = new Interpreter();
|
|
Func<double, double, double> pow = (x, y) => Math.Pow(x, y);
|
MyDelegate myDelegate = (x) => x.Length;
|
|
var parameters = new[] {
|
new Parameter("pow", pow.GetType(), pow),
|
new Parameter("myDelegate", myDelegate.GetType(), myDelegate)
|
};
|
|
Assert.That(target.Eval("pow(3, 2)", parameters), Is.EqualTo(9.0));
|
Assert.That(target.Eval("myDelegate(\"test\")", parameters), Is.EqualTo(4));
|
}
|
|
[Test]
|
public void When_parsing_an_expression_only_the_actually_used_parameters_should_be_included_in_the_lambda()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[] {
|
new Parameter("x", 23),
|
new Parameter("y", 7),
|
new Parameter("z", 54),
|
};
|
|
var lambda = target.Parse("x + y", parameters);
|
|
// parameter 'z' is not used
|
Assert.That(lambda.UsedParameters.Count(), Is.EqualTo(2));
|
Assert.That(lambda.UsedParameters.ElementAt(0).Name, Is.EqualTo("x"));
|
Assert.That(lambda.UsedParameters.ElementAt(1).Name, Is.EqualTo("y"));
|
|
Assert.That(lambda.DeclaredParameters.Count(), Is.EqualTo(3));
|
Assert.That(lambda.DeclaredParameters.ElementAt(0).Name, Is.EqualTo("x"));
|
Assert.That(lambda.DeclaredParameters.ElementAt(1).Name, Is.EqualTo("y"));
|
Assert.That(lambda.DeclaredParameters.ElementAt(2).Name, Is.EqualTo("z"));
|
}
|
|
[Test]
|
public void Using_the_same_parameters_multiple_times_doesnt_produce_multiple_parameters_in_the_lambda()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[] {
|
new Parameter("x", 23),
|
new Parameter("y", 7),
|
};
|
|
var lambda = target.Parse("x * y + x * y", parameters);
|
|
Assert.That(lambda.UsedParameters.Count(), Is.EqualTo(2));
|
Assert.That(lambda.UsedParameters.ElementAt(0).Name, Is.EqualTo("x"));
|
Assert.That(lambda.UsedParameters.ElementAt(1).Name, Is.EqualTo("y"));
|
}
|
|
[Test]
|
public void When_lambda_is_invoked_input_parameters_must_follow_in_the_same_order_in_which_they_were_transmitted_to_the_interpreter()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[]{
|
new Parameter("x", typeof(int)),
|
new Parameter("y", typeof(int))
|
};
|
|
var lambda = target.Parse("y-x", parameters);
|
|
Assert.That(lambda.Invoke(1, 5), Is.EqualTo(4));
|
}
|
|
[Test]
|
public void When_lambda_is_invoked_I_can_omit_parameters_not_used()
|
{
|
var target = new Interpreter();
|
|
var parameters = new[]{
|
new Parameter("x", typeof(int)),
|
new Parameter("y", typeof(int))
|
};
|
|
var lambda = target.Parse("y+5", parameters);
|
|
Assert.That(lambda.Invoke(new Parameter("y", 2)), Is.EqualTo(7));
|
}
|
|
[Test]
|
public void When_parsing_an_expression_to_a_delegate_the_delegate_parameters_are_respected_also_if_the_expression_doesnt_use_it()
|
{
|
var target = new Interpreter();
|
|
var myDelegate = target.ParseAsDelegate<TestDelegate>("x + y");
|
|
// parameter 'z' is not used but the delegate accept it in any case without problem
|
Assert.That(myDelegate(1, 2, 123123), Is.EqualTo(3));
|
Assert.That(myDelegate(21, 3, 433123), Is.EqualTo(24));
|
}
|
|
public delegate int TestDelegate(int x, int y, int z);
|
|
private class MyTestService
|
{
|
public DateTime AField = DateTime.Now;
|
|
public int AProperty
|
{
|
get { return 769; }
|
}
|
|
public string HelloWorld()
|
{
|
return "Ciao mondo";
|
}
|
|
public string CallMethod(string param1, int param2, DateTime param3)
|
{
|
return string.Format("{0} {1} {2}", param1, param2, param3);
|
}
|
}
|
|
private delegate int MyDelegate(string s);
|
|
}
|
}
|
