using System;
|
using System.Collections.Generic;
|
using System.Linq.Expressions;
|
using System.Reflection;
|
using DynamicExpresso.Exceptions;
|
using NUnit.Framework;
|
|
namespace DynamicExpresso.UnitTest
|
{
|
[TestFixture]
|
public class OperatorsTest
|
{
|
[Test]
|
public void Multiplicative_Operators()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("2 * 4"), Is.EqualTo(2 * 4));
|
Assert.That(target.Eval("8 / 2"), Is.EqualTo(8 / 2));
|
Assert.That(target.Eval("7 % 3"), Is.EqualTo(7 % 3));
|
}
|
|
[Test]
|
public void Additive_Operators()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("45 + 5"), Is.EqualTo(45 + 5));
|
Assert.That(target.Eval("45 - 5"), Is.EqualTo(45 - 5));
|
Assert.That(target.Eval("1.0 - 0.5"), Is.EqualTo(1.0 - 0.5));
|
}
|
|
[Test]
|
public void Unary_Operators()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("-45"), Is.EqualTo(-45));
|
Assert.That(target.Eval("+5"), Is.EqualTo(5));
|
Assert.That(target.Eval("!true"), Is.EqualTo(false));
|
|
Assert.That(target.Eval("~2"), Is.EqualTo(~2));
|
Assert.That(target.Eval("~2ul"), Is.EqualTo(~2ul));
|
}
|
|
[Test]
|
public void Shift_Operators()
|
{
|
var target = new Interpreter();
|
var x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
|
target.SetVariable("x", x);
|
|
Assert.That(target.Eval("x >> 4"), Is.EqualTo(x >> 4));
|
Assert.That(target.Eval("x << 4"), Is.EqualTo(x << 4));
|
|
// ensure they can be chained
|
Assert.That(target.Eval("x >> 1 >> 1 >> 1"), Is.EqualTo(x >> 1 >> 1 >> 1));
|
Assert.That(target.Eval("x << 1 << 1 << 1"), Is.EqualTo(x << 1 << 1 << 1));
|
|
// ensure priority
|
Assert.That(target.Eval<bool>("1 << 4 < 16"), Is.False);
|
Assert.That(target.Eval<bool>("1 << 4 < 17"), Is.True);
|
}
|
|
[Test]
|
public void Numeric_Logical_And()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(Convert));
|
|
var a = 0b_1111_1000;
|
var b = 0b_0001_1100;
|
target.SetVariable("a", a);
|
target.SetVariable("b", b);
|
|
Assert.That(target.Eval("a & b"), Is.EqualTo(a & b));
|
}
|
|
[Test]
|
public void Numeric_Logical_Or()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(Convert));
|
|
var a = 0b_1111_1000;
|
var b = 0b_0001_1100;
|
target.SetVariable("a", a);
|
target.SetVariable("b", b);
|
|
Assert.That(target.Eval("a | b"), Is.EqualTo(a | b));
|
}
|
|
[Test]
|
public void Numeric_Logical_Xor()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(Convert));
|
|
var a = 0b_1111_1000;
|
var b = 0b_0001_1100;
|
target.SetVariable("a", a);
|
target.SetVariable("b", b);
|
|
Assert.That(target.Eval("a ^ b"), Is.EqualTo(a ^ b));
|
}
|
|
[Test, Ignore("Current operator resolution doesn't lift int to uint")]
|
public void Bitwise_operations_uint_int()
|
{
|
var target = new Interpreter();
|
|
// ensure we can resolve operators between uint and int
|
var x = 0b_1111_1000u;
|
target.SetVariable("x", x);
|
|
Assert.That(target.Eval<uint>("~x"), Is.EqualTo(~x));
|
Assert.That(target.Eval<uint>("x >> 4"), Is.EqualTo(x >> 4));
|
Assert.That(target.Eval<uint>("x << 4"), Is.EqualTo(x << 4));
|
|
Assert.That(target.Eval<uint>("x & 4"), Is.EqualTo(x & 4));
|
Assert.That(target.Eval<uint>("x | 4"), Is.EqualTo(x | 4));
|
Assert.That(target.Eval<uint>("x ^ 4"), Is.EqualTo(x ^ 4));
|
}
|
|
[Test]
|
public void Unary_Cast_Operator()
|
{
|
var target = new Interpreter();
|
|
var x = 51.5;
|
target.SetVariable("x", x);
|
|
Assert.That(target.Eval("(int)x"), Is.EqualTo((int)x));
|
Assert.That(target.Parse("(int)x").ReturnType, Is.EqualTo(typeof(int)));
|
Assert.That(target.Parse("(object)x").ReturnType, Is.EqualTo(typeof(object)));
|
Assert.That(target.Eval("(double)84 + 9 *8"), Is.EqualTo((double)84 + 9 * 8));
|
}
|
|
[Test]
|
public void Numeric_Operators_Priority()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("8 / 2 + 2"), Is.EqualTo(8 / 2 + 2));
|
Assert.That(target.Eval("8 + 2 / 2"), Is.EqualTo(8 + 2 / 2));
|
}
|
|
[Test]
|
public void Typeof_Operator()
|
{
|
var target = new Interpreter();
|
|
Assert.Throws<ParseException>(() => target.Eval("typeof(int??)"));
|
Assert.Throws<ParseException>(() => target.Eval("typeof(string?)"));
|
|
Assert.That(target.Eval("typeof(string)"), Is.EqualTo(typeof(string)));
|
Assert.That(target.Eval("typeof(int)"), Is.EqualTo(typeof(int)));
|
Assert.That(target.Eval("typeof(int?)"), Is.EqualTo(typeof(int?)));
|
}
|
|
[Test]
|
public void Typeof_Operator_Arrays()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("typeof(int[])"), Is.EqualTo(typeof(int[])));
|
Assert.That(target.Eval("typeof(int?[])"), Is.EqualTo(typeof(int?[])));
|
Assert.That(target.Eval("typeof(int?[,,][][,])"), Is.EqualTo(typeof(int?[,,][][,])));
|
}
|
|
[Test]
|
public void Typeof_Operator_Generics()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(IEnumerable<>), "IEnumerable");
|
target.Reference(typeof(Dictionary<,>), "Dictionary");
|
|
Assert.That(target.Eval("typeof(IEnumerable<int>)"), Is.EqualTo(typeof(IEnumerable<int>)));
|
Assert.That(target.Eval("typeof(IEnumerable<IEnumerable<int?[]>>)"), Is.EqualTo(typeof(IEnumerable<IEnumerable<int?[]>>)));
|
Assert.That(target.Eval("typeof(IEnumerable<>)"), Is.EqualTo(typeof(IEnumerable<>)));
|
|
Assert.That(target.Eval("typeof(Dictionary<int,string>[,])"), Is.EqualTo(typeof(Dictionary<int, string>[,])));
|
Assert.That(target.Eval("typeof(Dictionary<int, IEnumerable<int[]>>)"), Is.EqualTo(typeof(Dictionary<int, IEnumerable<int[]>>)));
|
Assert.That(target.Eval("typeof(Dictionary<,>)"), Is.EqualTo(typeof(Dictionary<,>)));
|
}
|
|
[Test]
|
public void Typeof_Operator_Generics_Arity()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(Tuple<>));
|
target.Reference(typeof(Tuple<,>));
|
target.Reference(typeof(Tuple<,,>));
|
Assert.That(target.Eval("typeof(Tuple<>)"), Is.EqualTo(typeof(Tuple<>)));
|
Assert.That(target.Eval("typeof(Tuple<,>)"), Is.EqualTo(typeof(Tuple<,>)));
|
Assert.That(target.Eval("typeof(Tuple<,,>)"), Is.EqualTo(typeof(Tuple<,,>)));
|
}
|
|
[Test]
|
public void Is_Operator()
|
{
|
object a = "string value";
|
object b = 64;
|
var target = new Interpreter()
|
.SetVariable("a", a, typeof(object))
|
.SetVariable("b", b, typeof(object));
|
|
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
|
Assert.That(target.Eval("a is string"), Is.EqualTo(a is string));
|
Assert.That(target.Parse("a is string").ReturnType, Is.EqualTo(typeof(bool)));
|
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
|
Assert.That(target.Eval("b is string"), Is.EqualTo(b is string));
|
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
|
Assert.That(target.Eval("b is int"), Is.EqualTo(b is int));
|
}
|
|
[Test]
|
public void Is_Operator_Generics()
|
{
|
object a = Tuple.Create(1);
|
object b = Tuple.Create(1, 2);
|
var target = new Interpreter()
|
.SetVariable("a", a, typeof(object))
|
.SetVariable("b", b, typeof(object));
|
|
target.Reference(typeof(Tuple<>));
|
target.Reference(typeof(Tuple<,>));
|
|
Assert.That(target.Eval("a is Tuple<int>"), Is.EqualTo(true));
|
Assert.That(target.Parse("a is Tuple<int>").ReturnType, Is.EqualTo(typeof(bool)));
|
Assert.That(target.Eval("b is Tuple<int,int>"), Is.EqualTo(true));
|
}
|
|
[Test]
|
public void As_Operator()
|
{
|
object a = "string value";
|
object b = 64;
|
var target = new Interpreter()
|
.SetVariable("a", a, typeof(object))
|
.SetVariable("b", b, typeof(object));
|
|
// ReSharper disable once TryCastAlwaysSucceeds
|
Assert.That(target.Eval("a as string"), Is.EqualTo(a as string));
|
Assert.That(target.Parse("a as string").ReturnType, Is.EqualTo(typeof(string)));
|
// ReSharper disable once ExpressionIsAlwaysNull
|
Assert.That(target.Eval("b as string"), Is.EqualTo(b as string));
|
Assert.That(target.Parse("b as string").ReturnType, Is.EqualTo(typeof(string)));
|
}
|
|
[Test]
|
public void Type_Operators()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("typeof(string) != typeof(int)"), Is.EqualTo(typeof(string) != typeof(int)));
|
// ReSharper disable once EqualExpressionComparison
|
Assert.That(target.Eval("typeof(string) == typeof(string)"), Is.EqualTo(typeof(string) == typeof(string)));
|
}
|
|
[Test]
|
public void String_Concatenation()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("\"ciao \" + \"mondo\""), Is.EqualTo("ciao " + "mondo"));
|
}
|
|
[Test]
|
public void String_Concatenation_with_type_conversion()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("\"ciao \" + 1981"), Is.EqualTo("ciao " + 1981));
|
Assert.That(target.Eval("1981 + \"ciao \""), Is.EqualTo(1981 + "ciao "));
|
}
|
|
[Test]
|
public void String_Concatenation_check_string_method()
|
{
|
MethodInfo expectedMethod = typeof(string)
|
.GetMethod(nameof(String.Concat), new[] {typeof(string), typeof(string)});
|
|
Interpreter interpreter = new Interpreter();
|
|
string expressionText = "\"ciao \" + 1981";
|
|
Lambda lambda = interpreter.Parse(expressionText);
|
|
MethodCallExpression methodCallExpression = lambda.Expression as MethodCallExpression;
|
|
Assert.That(methodCallExpression, Is.Not.Null);
|
Assert.That(methodCallExpression.Method, Is.EqualTo(expectedMethod));
|
}
|
|
[Test]
|
public void String_Concatenation_with_null()
|
{
|
Interpreter interpreter = new Interpreter();
|
|
string expressionText = "\"ciao \" + null";
|
Assert.That(interpreter.Eval(expressionText), Is.EqualTo("ciao "));
|
|
Func<String> someFunc = () => null;
|
interpreter.SetFunction("someFunc", someFunc);
|
expressionText = "\"ciao \" + someFunc()";
|
Assert.That(interpreter.Eval(expressionText), Is.EqualTo("ciao "));
|
|
Func<Object> someFuncObject = () => null;
|
interpreter.SetFunction("someFuncObject", someFuncObject);
|
expressionText = "\"ciao \" + someFuncObject()";
|
Assert.That(interpreter.Eval(expressionText), Is.EqualTo("ciao "));
|
|
expressionText = "someFunc() + \"123\" + null + \"678\" + someFuncObject()";
|
Assert.That(interpreter.Eval(expressionText), Is.EqualTo("123678"));
|
}
|
|
private class MyClass
|
{
|
public override string ToString()
|
{
|
return "MyClassStr";
|
}
|
}
|
|
private class MyClassNullToString : MyClass
|
{
|
public override string ToString()
|
{
|
return null;
|
}
|
}
|
|
[Test]
|
public void String_Concatenation_with_overridden_ToString()
|
{
|
Interpreter interpreter = new Interpreter()
|
.SetVariable("myClass", new MyClass())
|
.SetVariable("myClassNullToString", new MyClassNullToString());
|
|
Assert.That(interpreter.Eval("\"ciao \" + myClass"), Is.EqualTo("ciao MyClassStr"));
|
Assert.That(interpreter.Eval("\"ciao \" + myClassNullToString"), Is.EqualTo("ciao "));
|
}
|
|
[Test]
|
public void Numeric_Expression()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("8 / (2 + 2)"), Is.EqualTo(8 / (2 + 2)));
|
Assert.That(target.Eval(" 58 / (2 * (8 + 2))"), Is.EqualTo(58 / (2 * (8 + 2))));
|
|
Assert.That(target.Eval("-(8 / (2 + 2))"), Is.EqualTo(-(8 / (2 + 2))));
|
Assert.That(target.Eval("+(8 / (2 + 2))"), Is.EqualTo(+(8 / (2 + 2))));
|
}
|
|
[Test]
|
public void Comparison_Operators()
|
{
|
var target = new Interpreter();
|
|
Assert.That((bool)target.Eval("0 > 3"), Is.False);
|
Assert.That((bool)target.Eval("0 >= 3"), Is.False);
|
Assert.That((bool)target.Eval("3 < 5"), Is.True);
|
Assert.That((bool)target.Eval("3 <= 5"), Is.True);
|
Assert.That((bool)target.Eval("5 == 3"), Is.False);
|
Assert.That((bool)target.Eval("5 == 5"), Is.True);
|
Assert.That((bool)target.Eval("5 >= 5"), Is.True);
|
Assert.That((bool)target.Eval("5 <= 5"), Is.True);
|
Assert.That((bool)target.Eval("5m >= 5m"), Is.True);
|
Assert.That((bool)target.Eval("5f <= 5f"), Is.True);
|
Assert.That((bool)target.Eval("5 != 3"), Is.True);
|
Assert.That((bool)target.Eval("\"dav\" == \"dav\""), Is.True);
|
Assert.That((bool)target.Eval("\"dav\" == \"jack\""), Is.False);
|
}
|
|
[Test]
|
public void Comparison_Operators_with_different_types()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("3 < 5f"), Is.EqualTo(3 < 5f));
|
Assert.That(target.Eval("3f < 5"), Is.EqualTo(3f < 5));
|
Assert.That(target.Eval("43 > 5m"), Is.EqualTo(43 > 5m));
|
Assert.That(target.Eval("34 == 34m"), Is.EqualTo(34 == 34m));
|
}
|
|
[Test]
|
public void Assignment_Operator_Equal()
|
{
|
var x = new TypeWithProperty();
|
|
var target = new Interpreter()
|
.SetVariable("x", x);
|
|
// simple assignment
|
target.Eval("x.Property1 = 156");
|
Assert.That(x.Property1, Is.EqualTo(156));
|
|
// assignment without space
|
target.Eval("x.Property1=156");
|
Assert.That(x.Property1, Is.EqualTo(156));
|
|
// assignment with many spaces
|
target.Eval("x.Property1 = 156");
|
Assert.That(x.Property1, Is.EqualTo(156));
|
|
// assignment should return the assigned value
|
var returnValue = target.Eval("x.Property1 = 81");
|
Assert.That(x.Property1, Is.EqualTo(81));
|
Assert.That(returnValue, Is.EqualTo(x.Property1));
|
|
// assignment can be chained
|
target.Eval("x.Property1 = x.Property2 = 2014");
|
Assert.That(x.Property1, Is.EqualTo(2014));
|
Assert.That(x.Property2, Is.EqualTo(x.Property1));
|
|
// assignment can be nested with other operators
|
returnValue = target.Eval("x.Property1 = (486 + 4) * 10");
|
Assert.That(x.Property1, Is.EqualTo(4900));
|
Assert.That(returnValue, Is.EqualTo(x.Property1));
|
|
// right member is not modified
|
x.Property2 = 2;
|
target.Eval("x.Property1 = x.Property2 * 10");
|
Assert.That(x.Property1, Is.EqualTo(20));
|
Assert.That(x.Property2, Is.EqualTo(2));
|
}
|
|
[Test]
|
public void Null_coalescing()
|
{
|
var interpreter = new Interpreter();
|
Assert.That(interpreter.Eval("null ?? null"), Is.Null);
|
Assert.That(interpreter.Eval("\"hallo\" ?? null"), Is.EqualTo("hallo"));
|
Assert.That(interpreter.Eval("null ?? \"hallo\""), Is.EqualTo("hallo"));
|
|
interpreter.SetVariable("x", null, typeof(string));
|
interpreter.SetVariable("y", "hello", typeof(string));
|
Assert.That(interpreter.Eval("x ?? null"), Is.Null);
|
Assert.That(interpreter.Eval("x ?? \"hallo\""), Is.EqualTo("hallo"));
|
Assert.That(interpreter.Eval("y ?? \"hallo\""), Is.EqualTo("hello"));
|
}
|
|
[Test]
|
public void Null_coalescing_precedence()
|
{
|
var interpreter = new Interpreter();
|
interpreter.SetVariable("x", null, typeof(double?));
|
|
Assert.That(interpreter.Eval("x * 2 ?? 50.5"), Is.EqualTo(50.5));
|
}
|
|
// ReSharper disable once UnusedAutoPropertyAccessor.Local
|
private class TypeWithProperty { public int Property1 { get; set; } public int Property2 { get; set; } }
|
|
[Test]
|
public void Can_assign_a_parameter()
|
{
|
var target = new Interpreter();
|
|
var result = target.Eval<int>("x = 5", new Parameter("x", 0));
|
|
Assert.That(result, Is.EqualTo(5));
|
}
|
|
[Test]
|
public void Cannot_assign_a_variable()
|
{
|
var target = new Interpreter()
|
.SetVariable("x", 0);
|
|
Assert.Throws<ParseException>(() => target.Parse("x = 5"));
|
}
|
|
[Test]
|
public void Assignment_Operators_can_be_disabled()
|
{
|
var target = new Interpreter()
|
.EnableAssignment(AssignmentOperators.None);
|
|
Assert.That(target.AssignmentOperators, Is.EqualTo(AssignmentOperators.None));
|
|
Assert.Throws<AssignmentOperatorDisabledException>(() => target.Parse("x = 5", new Parameter("x", 0)));
|
}
|
|
[Test]
|
public void Can_compare_numeric_parameters_of_different_compatible_types()
|
{
|
var target = new Interpreter();
|
|
double x1 = 5;
|
Assert.That(target.Eval("x > 3", new Parameter("x", x1)), Is.EqualTo(true));
|
double x2 = 1;
|
Assert.That(target.Eval("x > 3", new Parameter("x", x2)), Is.EqualTo(false));
|
decimal x3 = 5;
|
Assert.That(target.Eval("x > 3", new Parameter("x", x3)), Is.EqualTo(true));
|
decimal x4 = 1;
|
Assert.That(target.Eval("x > 3", new Parameter("x", x4)), Is.EqualTo(false));
|
int x5 = 1;
|
double y1 = 10;
|
Assert.That(target.Eval("x < y", new Parameter("x", x5), new Parameter("y", y1)), Is.EqualTo(true));
|
double x6 = 0;
|
Assert.That(target.Eval("x == 0", new Parameter("x", x6)), Is.EqualTo(true));
|
}
|
|
[Test]
|
public void Can_compare_enum_parameters()
|
{
|
var target = new Interpreter();
|
|
InterpreterOptions x = InterpreterOptions.CaseInsensitive;
|
InterpreterOptions y = InterpreterOptions.CaseInsensitive;
|
|
Assert.That(target.Eval("x == y", new Parameter("x", x), new Parameter("y", y)), Is.EqualTo(x == y));
|
|
y = InterpreterOptions.CommonTypes;
|
Assert.That(target.Eval("x != y", new Parameter("x", x), new Parameter("y", y)), Is.EqualTo(x != y));
|
}
|
|
[Test]
|
public void Conditional_Operators()
|
{
|
var target = new Interpreter();
|
|
Assert.That((bool)target.Eval("0 > 3 || true"), Is.True);
|
Assert.That((bool)target.Eval("0 > 3 && 4 < 6"), Is.False);
|
}
|
|
[Test]
|
public void Logical_ExclusiveOr()
|
{
|
var target = new Interpreter();
|
Assert.That((bool)target.Eval("true ^ false"), Is.True);
|
Assert.That((bool)target.Eval("false ^ true"), Is.True);
|
Assert.That((bool)target.Eval("true ^ true"), Is.False);
|
Assert.That((bool)target.Eval("false ^ false"), Is.False);
|
|
Assert.That(target.Eval("1 ^ 3"), Is.EqualTo(2));
|
Assert.That(target.Eval("1 ^ 2"), Is.EqualTo(3));
|
}
|
|
[Test]
|
public void Conditional_And()
|
{
|
var target = new Interpreter();
|
Assert.That((bool)target.Eval("true && false"), Is.False);
|
Assert.That((bool)target.Eval("false && true"), Is.False);
|
Assert.That((bool)target.Eval("true && true"), Is.True);
|
Assert.That((bool)target.Eval("false && false"), Is.False);
|
}
|
|
[Test]
|
public void Logical_And()
|
{
|
var target = new Interpreter();
|
Assert.That((bool)target.Eval("true & false"), Is.False);
|
Assert.That((bool)target.Eval("false & true"), Is.False);
|
Assert.That((bool)target.Eval("true & true"), Is.True);
|
Assert.That((bool)target.Eval("false & false"), Is.False);
|
|
Assert.That(target.Eval("1 & 3"), Is.EqualTo(1));
|
Assert.That(target.Eval("1 & 2"), Is.EqualTo(0));
|
}
|
|
[Test]
|
public void Conditional_Or()
|
{
|
var target = new Interpreter();
|
Assert.That((bool)target.Eval("true || false"), Is.True);
|
Assert.That((bool)target.Eval("false || true"), Is.True);
|
Assert.That((bool)target.Eval("true || true"), Is.True);
|
Assert.That((bool)target.Eval("false || false"), Is.False);
|
}
|
|
[Test]
|
public void Logical_Or()
|
{
|
var target = new Interpreter();
|
Assert.That((bool)target.Eval("true | false"), Is.True);
|
Assert.That((bool)target.Eval("false | true"), Is.True);
|
Assert.That((bool)target.Eval("true | true"), Is.True);
|
Assert.That((bool)target.Eval("false | false"), Is.False);
|
|
Assert.That(target.Eval("1 | 3"), Is.EqualTo(3));
|
Assert.That(target.Eval("1 | 2"), Is.EqualTo(3));
|
}
|
|
[Test]
|
public void Operators_Precedence()
|
{
|
// Precedence:
|
// &, ^, |, &&, ||
|
// From: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/
|
|
var target = new Interpreter();
|
Assert.That(target.Eval("false ^ false | true & true"), Is.EqualTo(false ^ false | true & true));
|
Assert.That(target.Eval("false & false ^ false | true"), Is.EqualTo(false & false ^ false | true));
|
Assert.That(target.Eval("true ^ true & false"), Is.EqualTo(true ^ true & false));
|
Assert.That(target.Eval("true ^ true && false"), Is.EqualTo(true ^ true && false));
|
}
|
|
[Test]
|
public void If_Operators()
|
{
|
var target = new Interpreter();
|
|
// ReSharper disable once UnreachableCode
|
Assert.That(target.Eval("10 > 3 ? \"yes\" : \"no\""), Is.EqualTo(10 > 3 ? "yes" : "no"));
|
// ReSharper disable once UnreachableCode
|
Assert.That(target.Eval("10 < 3 ? \"yes\" : \"no\""), Is.EqualTo(10 < 3 ? "yes" : "no"));
|
}
|
|
[Test]
|
public void Operator_LessGreater_Is_Not_Supported()
|
{
|
var target = new Interpreter();
|
|
Assert.Throws<ParseException>(() => target.Parse("5 <> 4"));
|
}
|
|
[Test]
|
public void Implicit_conversion_operator_for_lambda()
|
{
|
var target = new Interpreter()
|
.SetVariable("x", new TypeWithImplicitConversion(10));
|
|
var func = target.ParseAsDelegate<Func<int>>("x");
|
var val = func();
|
|
Assert.That(val, Is.EqualTo(10));
|
}
|
|
private struct TypeWithImplicitConversion
|
{
|
private int _value;
|
|
public TypeWithImplicitConversion(byte value)
|
{
|
_value = value;
|
}
|
|
public static implicit operator int(TypeWithImplicitConversion d)
|
{
|
return d._value;
|
}
|
}
|
|
[Test]
|
public void Can_use_overloaded_operators_on_struct()
|
{
|
var target = new Interpreter();
|
|
var x = new StructWithOverloadedBinaryOperators(3);
|
target.SetVariable("x", x);
|
|
var y = "5";
|
Assert.That(x == y, Is.False);
|
Assert.That(target.Eval<bool>("x == y", new Parameter("y", y)), Is.False);
|
|
y = "3";
|
Assert.That(x == y, Is.True);
|
Assert.That(target.Eval<bool>("x == y", new Parameter("y", y)), Is.True);
|
|
Assert.That(target.Eval<bool>("x == \"4\""), Is.False);
|
Assert.That(target.Eval<bool>("x == \"3\""), Is.True);
|
|
Assert.That(!x == "-3", Is.True);
|
Assert.That(target.Eval<bool>("!x == \"-3\""), Is.True);
|
|
var z = new StructWithOverloadedBinaryOperators(10);
|
Assert.That((x + z) == "13", Is.True);
|
Assert.That(target.Eval<bool>("(x + z) == \"13\"", new Parameter("z", z)), Is.True);
|
}
|
|
private struct StructWithOverloadedBinaryOperators
|
{
|
private readonly int _value;
|
|
public StructWithOverloadedBinaryOperators(int value)
|
{
|
_value = value;
|
}
|
|
public static bool operator ==(StructWithOverloadedBinaryOperators instance, string value)
|
{
|
return instance._value.ToString().Equals(value);
|
}
|
|
public static bool operator !=(StructWithOverloadedBinaryOperators instance, string value)
|
{
|
return !instance._value.ToString().Equals(value);
|
}
|
|
public static StructWithOverloadedBinaryOperators operator +(StructWithOverloadedBinaryOperators left, StructWithOverloadedBinaryOperators right)
|
{
|
return new StructWithOverloadedBinaryOperators(left._value + right._value);
|
}
|
|
public static StructWithOverloadedBinaryOperators operator !(StructWithOverloadedBinaryOperators instance)
|
{
|
return new StructWithOverloadedBinaryOperators(-instance._value);
|
}
|
|
public override bool Equals(object obj)
|
{
|
if (obj == null)
|
return false;
|
if (obj is StructWithOverloadedBinaryOperators)
|
{
|
return _value.Equals(((StructWithOverloadedBinaryOperators)obj)._value);
|
}
|
return base.Equals(obj);
|
}
|
|
public override int GetHashCode()
|
{
|
return _value.GetHashCode();
|
}
|
}
|
|
[Test]
|
public void Can_use_overloaded_operators_on_class()
|
{
|
var target = new Interpreter();
|
|
var x = new ClassWithOverloadedBinaryOperators(3);
|
target.SetVariable("x", x);
|
|
string y = "5";
|
Assert.That(x == y, Is.False);
|
Assert.That(target.Eval<bool>("x == y", new Parameter("y", y)), Is.False);
|
|
y = "3";
|
Assert.That(x == y, Is.True);
|
Assert.That(target.Eval<bool>("x == y", new Parameter("y", y)), Is.True);
|
|
Assert.That(target.Eval<bool>("x == \"4\""), Is.False);
|
Assert.That(target.Eval<bool>("x == \"3\""), Is.True);
|
|
Assert.That(!x == "-3", Is.True);
|
Assert.That(target.Eval<bool>("!x == \"-3\""), Is.True);
|
|
var z = new ClassWithOverloadedBinaryOperators(10);
|
Assert.That((x + z) == "13", Is.True);
|
Assert.That(target.Eval<bool>("(x + z) == \"13\"", new Parameter("z", z)), Is.True);
|
}
|
|
private class ClassWithOverloadedBinaryOperators
|
{
|
private readonly int _value;
|
|
public ClassWithOverloadedBinaryOperators(int value)
|
{
|
_value = value;
|
}
|
|
public static bool operator ==(ClassWithOverloadedBinaryOperators instance, string value)
|
{
|
return ReferenceEquals(instance, null) == false
|
&& instance._value.ToString().Equals(value);
|
}
|
|
public static bool operator !=(ClassWithOverloadedBinaryOperators instance, string value)
|
{
|
if (ReferenceEquals(instance, null))
|
return value != null;
|
|
return !instance._value.ToString().Equals(value);
|
}
|
|
public static ClassWithOverloadedBinaryOperators operator +(ClassWithOverloadedBinaryOperators left, ClassWithOverloadedBinaryOperators right)
|
{
|
return new ClassWithOverloadedBinaryOperators(left._value + right._value);
|
}
|
|
public static ClassWithOverloadedBinaryOperators operator !(ClassWithOverloadedBinaryOperators instance)
|
{
|
return new ClassWithOverloadedBinaryOperators(-instance._value);
|
}
|
|
public static ClassWithOverloadedBinaryOperators operator *(ClassWithOverloadedBinaryOperators left, int right)
|
{
|
return new ClassWithOverloadedBinaryOperators(left._value * right);
|
}
|
|
public static ClassWithOverloadedBinaryOperators operator *(int left, ClassWithOverloadedBinaryOperators right)
|
{
|
return new ClassWithOverloadedBinaryOperators(left * right._value);
|
}
|
|
public override bool Equals(object obj)
|
{
|
if (obj == null)
|
return false;
|
var operators = obj as ClassWithOverloadedBinaryOperators;
|
return operators != null ? _value.Equals(operators._value) : base.Equals(obj);
|
}
|
|
public override int GetHashCode()
|
{
|
return _value.GetHashCode();
|
}
|
}
|
|
private class DerivedClassWithOverloadedBinaryOperators : ClassWithOverloadedBinaryOperators
|
{
|
public DerivedClassWithOverloadedBinaryOperators(int value) : base(value)
|
{
|
}
|
}
|
|
[Test]
|
public void Can_use_overloaded_operators_on_derived_class()
|
{
|
var target = new Interpreter();
|
|
var x = new DerivedClassWithOverloadedBinaryOperators(3);
|
target.SetVariable("x", x);
|
|
string y = "5";
|
Assert.That(x == y, Is.False);
|
Assert.That(target.Eval<bool>("x == y", new Parameter("y", y)), Is.False);
|
|
y = "3";
|
Assert.That(x == y, Is.True);
|
Assert.That(target.Eval<bool>("x == y", new Parameter("y", y)), Is.True);
|
|
Assert.That(target.Eval<bool>("x == \"4\""), Is.False);
|
Assert.That(target.Eval<bool>("x == \"3\""), Is.True);
|
|
Assert.That(!x == "-3", Is.True);
|
Assert.That(target.Eval<bool>("!x == \"-3\""), Is.True);
|
|
var z = new DerivedClassWithOverloadedBinaryOperators(10);
|
Assert.That((x + z) == "13", Is.True);
|
Assert.That(target.Eval<bool>("(x + z) == \"13\"", new Parameter("z", z)), Is.True);
|
|
Assert.That((x * 4) == "12", Is.True);
|
Assert.That(target.Eval<bool>("(x * 4) == \"12\""), Is.True);
|
|
// ensure a user defined operator can be found if it's on the right side operand's type
|
Assert.That((4 * x) == "12", Is.True);
|
Assert.That(target.Eval<bool>("(4 * x) == \"12\""), Is.True);
|
}
|
|
[Test]
|
public void Can_mix_overloaded_operators()
|
{
|
var target = new Interpreter();
|
|
var x = new ClassWithOverloadedBinaryOperators(3);
|
target.SetVariable("x", x);
|
|
// ensure we don't trigger an ambiguous operator exception
|
var z = new DerivedClassWithOverloadedBinaryOperators(10);
|
Assert.That((x + z) == "13", Is.True);
|
Assert.That(target.Eval<bool>("(x + z) == \"13\"", new Parameter("z", z)), Is.True);
|
}
|
|
|
[Test]
|
public void Throw_an_exception_if_a_custom_type_doesnt_define_equal_operator()
|
{
|
var target = new Interpreter();
|
|
var x = new TypeWithoutOverloadedBinaryOperators(3);
|
target.SetVariable("x", x);
|
|
var y = "5";
|
|
var ex = Assert.Throws<ParseException>(() => target.Parse("x == y", new Parameter("y", y)));
|
Assert.That(ex.InnerException, Is.InstanceOf<InvalidOperationException>());
|
}
|
|
[Test]
|
public void Throw_an_exception_if_a_custom_type_doesnt_define_plus_operator()
|
{
|
var target = new Interpreter();
|
|
var x = new TypeWithoutOverloadedBinaryOperators(3);
|
target.SetVariable("x", x);
|
|
var y = 5;
|
|
var ex = Assert.Throws<ParseException>(() => target.Parse("x + y", new Parameter("y", y)));
|
Assert.That(ex.InnerException, Is.InstanceOf<InvalidOperationException>());
|
}
|
|
[Test]
|
public void Throw_an_exception_if_a_custom_type_doesnt_define_not_operator()
|
{
|
var target = new Interpreter();
|
|
var x = new TypeWithoutOverloadedBinaryOperators(3);
|
target.SetVariable("x", x);
|
|
var ex = Assert.Throws<ParseException>(() => target.Parse("!x"));
|
Assert.That(ex.InnerException, Is.InstanceOf<InvalidOperationException>());
|
}
|
|
private struct TypeWithoutOverloadedBinaryOperators
|
{
|
// ReSharper disable once UnusedParameter.Local
|
public TypeWithoutOverloadedBinaryOperators(int value)
|
{
|
}
|
}
|
}
|
}
|
