using System;
|
using System.Collections.Generic;
|
using System.Dynamic;
|
using System.Linq.Expressions;
|
using DynamicExpresso.Exceptions;
|
using Microsoft.CSharp.RuntimeBinder;
|
using NUnit.Framework;
|
|
namespace DynamicExpresso.UnitTest
|
{
|
[TestFixture]
|
public class DynamicTest
|
{
|
[Test]
|
public void Get_Property_of_an_ExpandoObject()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = "bar";
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("dyn.Foo"), Is.EqualTo(dyn.Foo));
|
}
|
|
[Test]
|
public void Set_Property_of_an_ExpandoObject()
|
{
|
dynamic dyn = new ExpandoObject();
|
var interpreter = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LateBindObject)
|
.SetVariable("dyn", (object)dyn);
|
|
interpreter.Eval("dyn.Foo = 10");
|
|
Assert.That(dyn.Foo, Is.EqualTo(10));
|
}
|
|
[Test]
|
public void Get_Property_of_a_nested_anonymous()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Sub = new { Foo = new { Bar = new { Foo2 = "bar" } } };
|
var interpreter = new Interpreter().SetVariable("dyn", (object)dyn);
|
Assert.That(interpreter.Eval("dyn.Sub.Foo.Bar.Foo2"), Is.EqualTo(dyn.Sub.Foo.Bar.Foo2));
|
}
|
|
[Test]
|
public void Set_Property_of_a_nested_ExpandoObject()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Sub = new ExpandoObject();
|
dyn.Sub.Foo = "bar";
|
|
var interpreter = new Interpreter().SetVariable("dyn", (object)dyn);
|
|
interpreter.Eval("dyn.Sub.Foo = \"foobar\"");
|
|
Assert.That(dyn.Sub.Foo, Is.EqualTo("foobar"));
|
}
|
|
[Test]
|
public void Get_Property_of_a_nested_ExpandoObject()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Sub = new ExpandoObject();
|
dyn.Sub.Foo = "bar";
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("dyn.Sub.Foo"), Is.EqualTo(dyn.Sub.Foo));
|
}
|
|
//[Test]
|
//public void Set_Property_of_an_ExpandoObject()
|
//{
|
// dynamic dyn = new ExpandoObject();
|
|
// var interpreter = new Interpreter()
|
// .SetVariable("dyn", dyn);
|
|
// interpreter.Eval("dyn.Foo = 6");
|
|
// Assert.That(dyn.Foo, Is.EqualTo(6));
|
//}
|
|
[Test]
|
public void Standard_properties_have_precedence_over_dynamic_properties()
|
{
|
var dyn = new TestDynamicClass();
|
dyn.RealProperty = "bar";
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", dyn);
|
|
Assert.That(interpreter.Eval("dyn.RealProperty"), Is.EqualTo(dyn.RealProperty));
|
}
|
|
[Test]
|
public void Invoke_Method_of_an_ExpandoObject()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = new Func<string>(() => "bar");
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", dyn);
|
|
Assert.That(interpreter.Eval("dyn.Foo()"), Is.EqualTo(dyn.Foo()));
|
}
|
|
[Test]
|
public void Invoke_Method_of_a_nested_ExpandoObject()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Sub = new ExpandoObject();
|
dyn.Sub.Foo = new Func<string>(() => "bar");
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", dyn);
|
|
Assert.That(interpreter.Eval("dyn.Sub.Foo()"), Is.EqualTo(dyn.Sub.Foo()));
|
}
|
|
[Test]
|
public void Invoke_Method_of_a_nested_ExpandoObject_WithAnonymousType()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Sub = new ExpandoObject();
|
dyn.Sub.Foo = new { Func = new Func<string>(() => "bar") };
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", dyn);
|
|
Assert.That(interpreter.Eval("dyn.Sub.Foo.Func()"), Is.EqualTo(dyn.Sub.Foo.Func()));
|
}
|
|
[Test]
|
public void Standard_methods_have_precedence_over_dynamic_methods()
|
{
|
var dyn = new TestDynamicClass();
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", dyn);
|
|
Assert.That(interpreter.Eval("dyn.ToString()"), Is.EqualTo(dyn.ToString()));
|
}
|
|
[Test]
|
public void Case_Insensitive_Dynamic_Members()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Bar = 10;
|
|
var interpreter = new Interpreter();
|
Assert.Throws<RuntimeBinderException>(() => interpreter.Eval("dyn.BAR", new Parameter("dyn", dyn)));
|
}
|
|
[Test]
|
public void Get_value_of_a_nested_array()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Sub = new int[] { 42 };
|
var interpreter = new Interpreter().SetVariable("dyn", (object)dyn);
|
Assert.That(interpreter.Eval("dyn.Sub[0]"), Is.EqualTo(dyn.Sub[0]));
|
}
|
|
[Test]
|
public void Get_value_of_a_nested_array_from_anonymous_type()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Sub = new { Foo = new int[] { 42 }, Bar = new { Sub = new int[] { 43 } } };
|
var interpreter = new Interpreter().SetVariable("dyn", (object)dyn);
|
Assert.That(interpreter.Eval("dyn.Sub.Foo[0]"), Is.EqualTo(dyn.Sub.Foo[0]));
|
Assert.That(interpreter.Eval("dyn.Sub.Bar.Sub[0]"), Is.EqualTo(dyn.Sub.Bar.Sub[0]));
|
Assert.That(interpreter.Eval("dyn.Sub.Bar.Sub.Length"), Is.EqualTo(dyn.Sub.Bar.Sub.Length));
|
}
|
|
[Test]
|
public void Get_value_of_an_array_of_anonymous_type()
|
{
|
dynamic dyn = new ExpandoObject();
|
var anonType1 = new { Foo = string.Empty };
|
var anonType2 = new { Foo = "string.Empty" };
|
var nullAnonType = anonType1;
|
nullAnonType = null;
|
dyn.Sub = new
|
{
|
Arg1 = anonType1,
|
Arg2 = anonType2,
|
Arg3 = nullAnonType,
|
Arr = new[] { anonType1, anonType2, nullAnonType },
|
ObjArr = new object[] { "Test", anonType1 }
|
};
|
var interpreter = new Interpreter().SetVariable("dyn", (object)dyn);
|
Assert.That(interpreter.Eval("dyn.Sub.Arg1.Foo"), Is.SameAs(dyn.Sub.Arg1.Foo));
|
Assert.That(interpreter.Eval("dyn.Sub.Arg2.Foo"), Is.SameAs(dyn.Sub.Arg2.Foo));
|
Assert.Throws<RuntimeBinderException>(() => Console.WriteLine(dyn.Sub.Arg3.Foo));
|
Assert.Throws<RuntimeBinderException>(() => interpreter.Eval("dyn.Sub.Arg3.Foo"));
|
Assert.That(interpreter.Eval("dyn.Sub.Arr[0].Foo"), Is.SameAs(dyn.Sub.Arr[0].Foo));
|
Assert.That(interpreter.Eval("dyn.Sub.Arr[1].Foo"), Is.SameAs(dyn.Sub.Arr[1].Foo));
|
|
Assert.Throws<RuntimeBinderException>(() => Console.WriteLine(dyn.Sub.Arr[2].Foo));
|
Assert.Throws<RuntimeBinderException>(() => interpreter.Eval("dyn.Sub.Arr[2].Foo"));
|
|
Assert.That(interpreter.Eval("dyn.Sub.ObjArr[0]"), Is.SameAs(dyn.Sub.ObjArr[0]));
|
Assert.That(interpreter.Eval("dyn.Sub.ObjArr[0].Length"), Is.EqualTo(dyn.Sub.ObjArr[0].Length));
|
|
Assert.That(interpreter.Eval("dyn.Sub.ObjArr[1]"), Is.SameAs(dyn.Sub.ObjArr[1]));
|
Assert.That(interpreter.Eval("dyn.Sub.ObjArr[1].Foo"), Is.SameAs(dyn.Sub.ObjArr[1].Foo));
|
}
|
|
[Test]
|
public void Set_value_of_a_dynamic_object()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = new int[5];
|
dyn.Bar = new Dictionary<string, int>();
|
|
var interpreter = new Interpreter().SetVariable("dyn", (object)dyn);
|
interpreter.Eval("dyn.Foo[2] = 5");
|
interpreter.Eval("dyn.Bar[\"foo\"] = 50");
|
|
Assert.That(dyn.Foo[2], Is.EqualTo(5));
|
Assert.That(dyn.Bar["foo"], Is.EqualTo(50));
|
}
|
|
[Test]
|
public void Get_value_of_a_nested_array_error()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Sub = new int[] { 42 };
|
dyn.Bar = 123;
|
var interpreter = new Interpreter().SetVariable("dyn", (object)dyn);
|
Assert.Throws<RuntimeBinderException>(() => interpreter.Eval("dyn.Bar[0]")); // use index for a property that is not an array
|
Assert.Throws<RuntimeBinderException>(() => interpreter.Eval("dyn.Sub[\"hello\"]")); // use as an index an invalid type (e.g. string)
|
Assert.Throws<ParseException>(() => interpreter.Eval("dyn.Sub[0"));// pass some invalid syntax
|
Assert.Throws<ParseException>(() => interpreter.Eval("dyn.Sub 0]")); // pass some invalid syntax
|
Assert.Throws<ParseException>(() => interpreter.Eval("dyn.Sub[[0]]")); // pass some invalid syntax
|
Assert.Throws<IndexOutOfRangeException>(() => interpreter.Eval("dyn.Sub[1]")); // get an out of bound element
|
}
|
|
[Test]
|
public void Test_With_Standard_Object()
|
{
|
var myInstance = DateTime.Now;
|
|
var methodInfo = myInstance.GetType().GetMethod("ToUniversalTime");
|
|
var methodCallExpression = Expression.Call(Expression.Constant(myInstance), methodInfo);
|
var expression = Expression.Lambda(methodCallExpression);
|
|
Assert.That(expression.Compile().DynamicInvoke(), Is.EqualTo(myInstance.ToUniversalTime()));
|
}
|
|
[Test]
|
public void Test_With_Dynamic_Object()
|
{
|
dynamic myInstance = new ExpandoObject();
|
myInstance.MyMethod = new Func<string>(() => "hello world");
|
|
var binder = Binder.InvokeMember(
|
CSharpBinderFlags.None,
|
"MyMethod",
|
null,
|
this.GetType(),
|
new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.Constant, null) });
|
|
var methodCallExpression = Expression.Dynamic(binder, typeof(object), Expression.Constant(myInstance));
|
var expression = Expression.Lambda(methodCallExpression);
|
|
Assert.That(expression.Compile().DynamicInvoke(), Is.EqualTo(myInstance.MyMethod()));
|
}
|
|
[Test]
|
public void Test_With_Dynamic_Object_By_Index_Access()
|
{
|
DynamicIndexAccess globals = new DynamicIndexAccess();
|
Interpreter interpreter = new Interpreter()
|
.SetVariable("Values", new DynamicIndexAccess());
|
|
Assert.That(interpreter.Eval<string>("Values[\"Hello\"]"), Is.EqualTo(globals.Values["Hello"]));
|
}
|
|
[Test]
|
public void Comparison_with_dynamic_properties()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = 500;
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("dyn.Foo == 500"), Is.EqualTo(dyn.Foo == 500));
|
Assert.That(interpreter.Eval("500 == dyn.Foo"), Is.EqualTo(500 == dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo != 200"), Is.EqualTo(dyn.Foo != 200));
|
Assert.That(interpreter.Eval("200 != dyn.Foo"), Is.EqualTo(200 != dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo > 200"), Is.EqualTo(dyn.Foo > 200));
|
Assert.That(interpreter.Eval("600 > dyn.Foo"), Is.EqualTo(600 > dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo < 600"), Is.EqualTo(dyn.Foo < 600));
|
Assert.That(interpreter.Eval("200 < dyn.Foo"), Is.EqualTo(200 < dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo >= 500"), Is.EqualTo(dyn.Foo >= 500));
|
Assert.That(interpreter.Eval("500 >= dyn.Foo"), Is.EqualTo(500 >= dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo <= 500"), Is.EqualTo(dyn.Foo <= 500));
|
Assert.That(interpreter.Eval("500 <= dyn.Foo"), Is.EqualTo(500 <= dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo + 500"), Is.EqualTo(dyn.Foo + 500));
|
Assert.That(interpreter.Eval("500 + dyn.Foo"), Is.EqualTo(500 + dyn.Foo));
|
}
|
|
[Test]
|
public void Conditional_with_dynamic_properties()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = 500;
|
dyn.Bar = 100;
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("dyn.Bar>0?100:200"), Is.EqualTo(dyn.Bar > 0 ? 100 : 200));
|
}
|
|
[Test]
|
public void AndAlso_with_dynamic_properties()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = 500;
|
dyn.Bar = 100;
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("dyn.Foo == 500 && dyn.Bar == 100"), Is.EqualTo(dyn.Foo == 500 && dyn.Bar == 100));
|
Assert.That(interpreter.Eval("dyn.Foo == 500 && dyn.Bar != 100"), Is.EqualTo(dyn.Foo == 500 && dyn.Bar != 100));
|
Assert.That(interpreter.Eval("dyn.Foo != 500 && dyn.Bar == 100"), Is.EqualTo(dyn.Foo != 500 && dyn.Bar == 100));
|
Assert.That(interpreter.Eval("dyn.Foo != 500 && dyn.Bar != 100"), Is.EqualTo(dyn.Foo != 500 && dyn.Bar != 100));
|
|
//check non dynamic right side
|
Assert.That(interpreter.Eval("dyn.Foo == 500 && 100 == 100"), Is.EqualTo(dyn.Foo == 500 && 100 == 100));
|
Assert.That(interpreter.Eval("dyn.Foo == 500 && 100 != 100"), Is.EqualTo(dyn.Foo == 500 && 100 != 100));
|
Assert.That(interpreter.Eval("dyn.Foo != 500 && 100 == 100"), Is.EqualTo(dyn.Foo != 500 && 100 == 100));
|
Assert.That(interpreter.Eval("dyn.Foo != 500 && 100 != 100"), Is.EqualTo(dyn.Foo != 500 && 100 != 100));
|
|
//check non dynamic left side
|
Assert.That(interpreter.Eval("100 == 100 && dyn.Foo == 500"), Is.EqualTo(100 == 100 && dyn.Foo == 500));
|
Assert.That(interpreter.Eval("100 != 100 && dyn.Foo == 500"), Is.EqualTo(100 != 100 && dyn.Foo == 500));
|
Assert.That(interpreter.Eval("100 == 100 && dyn.Foo != 500"), Is.EqualTo(100 == 100 && dyn.Foo != 500));
|
Assert.That(interpreter.Eval("100 != 100 && dyn.Foo != 500"), Is.EqualTo(100 != 100 && dyn.Foo != 500));
|
}
|
|
[Test]
|
public void OrElse_with_dynamic_properties()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = 500;
|
dyn.Bar = 100;
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("dyn.Foo == 500 || dyn.Bar == 100"), Is.EqualTo(dyn.Foo == 500 || dyn.Bar == 100));
|
Assert.That(interpreter.Eval("dyn.Foo == 500 || dyn.Bar != 100"), Is.EqualTo(dyn.Foo == 500 || dyn.Bar != 100));
|
Assert.That(interpreter.Eval("dyn.Foo != 500 || dyn.Bar == 100"), Is.EqualTo(dyn.Foo != 500 || dyn.Bar == 100));
|
Assert.That(interpreter.Eval("dyn.Foo != 500 || dyn.Bar != 100"), Is.EqualTo(dyn.Foo != 500 || dyn.Bar != 100));
|
|
//check non dynamic right side
|
Assert.That(interpreter.Eval("dyn.Foo == 500 || 100 == 100"), Is.EqualTo(dyn.Foo == 500 || 100 == 100));
|
Assert.That(interpreter.Eval("dyn.Foo == 500 || 100 != 100"), Is.EqualTo(dyn.Foo == 500 || 100 != 100));
|
Assert.That(interpreter.Eval("dyn.Foo != 500 || 100 == 100"), Is.EqualTo(dyn.Foo != 500 || 100 == 100));
|
Assert.That(interpreter.Eval("dyn.Foo != 500 || 100 != 100"), Is.EqualTo(dyn.Foo != 500 || 100 != 100));
|
|
//check non dynamic left side
|
Assert.That(interpreter.Eval("100 == 100 || dyn.Foo == 500"), Is.EqualTo(100 == 100 || dyn.Foo == 500));
|
Assert.That(interpreter.Eval("100 != 100 || dyn.Foo == 500"), Is.EqualTo(100 != 100 || dyn.Foo == 500));
|
Assert.That(interpreter.Eval("100 == 100 || dyn.Foo != 500"), Is.EqualTo(100 == 100 || dyn.Foo != 500));
|
Assert.That(interpreter.Eval("100 != 100 || dyn.Foo != 500"), Is.EqualTo(100 != 100 || dyn.Foo != 500));
|
}
|
|
[Test]
|
public void Math_with_dynamic_properties()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = 500;
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("dyn.Foo + 500"), Is.EqualTo(dyn.Foo + 500));
|
Assert.That(interpreter.Eval("500 + dyn.Foo"), Is.EqualTo(500 + dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo - 500"), Is.EqualTo(dyn.Foo - 500));
|
Assert.That(interpreter.Eval("500 - dyn.Foo"), Is.EqualTo(500 - dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo / 500"), Is.EqualTo(dyn.Foo / 500));
|
Assert.That(interpreter.Eval("500 / dyn.Foo"), Is.EqualTo(500 / dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo * 500"), Is.EqualTo(dyn.Foo * 500));
|
Assert.That(interpreter.Eval("500 * dyn.Foo"), Is.EqualTo(500 * dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo % 500"), Is.EqualTo(dyn.Foo % 500));
|
Assert.That(interpreter.Eval("500 % dyn.Foo"), Is.EqualTo(500 % dyn.Foo));
|
}
|
|
public class ClassWithObjectProperties
|
{
|
public object Foo => 100;
|
public object Bar() => 100;
|
}
|
|
[Test]
|
public void ObjectLateBinding()
|
{
|
|
|
var classWithObjectProperties = new ClassWithObjectProperties();
|
|
|
Assert.Throws<ParseException>(() =>
|
{
|
|
var noLateBindingInterpreter = new Interpreter();
|
var noLateBindingDel = noLateBindingInterpreter.ParseAsDelegate<Func<ClassWithObjectProperties, int>>("d.Foo+d.Bar()", new[] { "d" });
|
var noLateBindingResult = noLateBindingDel.Invoke(classWithObjectProperties);
|
|
});
|
|
|
var lateBindingInterpreter = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LateBindObject);
|
var lateBindingInterpreterDel = lateBindingInterpreter.ParseAsDelegate<Func<ClassWithObjectProperties, int>>("d.Foo+d.Bar()", new[] { "d" });
|
var lateBindingResult = lateBindingInterpreterDel.Invoke(classWithObjectProperties);
|
Assert.That(lateBindingResult, Is.EqualTo((dynamic)classWithObjectProperties.Foo + (dynamic)classWithObjectProperties.Bar()));
|
|
|
lateBindingInterpreter.SetVariable("d", classWithObjectProperties);
|
var evalResult = lateBindingInterpreter.Eval("d.Foo+d.Bar()");
|
Assert.That(evalResult.GetType(), Is.EqualTo(typeof(int)));
|
Assert.That(evalResult, Is.EqualTo((dynamic)classWithObjectProperties.Foo + (dynamic)classWithObjectProperties.Bar()));
|
|
}
|
|
|
[Test]
|
public void Bitwise_with_dynamic_properties()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = 500;
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("dyn.Foo & 500"), Is.EqualTo(dyn.Foo & 500));
|
Assert.That(interpreter.Eval("500 & dyn.Foo"), Is.EqualTo(500 & dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo | 500"), Is.EqualTo(dyn.Foo | 500));
|
Assert.That(interpreter.Eval("500 | dyn.Foo"), Is.EqualTo(500 | dyn.Foo));
|
|
Assert.That(interpreter.Eval("dyn.Foo ^ 500"), Is.EqualTo(dyn.Foo ^ 500));
|
Assert.That(interpreter.Eval("500 ^ dyn.Foo"), Is.EqualTo(500 ^ dyn.Foo));
|
|
}
|
|
[Test]
|
public void Unary_with_dynamic_properties()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = true;
|
dyn.Bar = 500;
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("!dyn.Foo"), Is.EqualTo(!dyn.Foo));
|
Assert.That(interpreter.Eval("-dyn.Bar"), Is.EqualTo(-dyn.Bar));
|
}
|
|
[Test]
|
public void Static_method_call_with_dynamic_arg()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = "test";
|
|
var myClass = new MyClass();
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn);
|
|
Assert.That(interpreter.Eval("string.IsNullOrEmpty(dyn.Foo)"), Is.EqualTo(string.IsNullOrEmpty(dyn.Foo)));
|
}
|
|
|
[Test]
|
public void Method_call_with_dynamic_arg()
|
{
|
dynamic dyn = new ExpandoObject();
|
dyn.Foo = "test";
|
|
var myClass = new MyClass();
|
|
var interpreter = new Interpreter()
|
.SetVariable("dyn", (object)dyn)
|
.SetVariable("myClass", myClass);
|
|
Assert.That(interpreter.Eval("myClass.MyMethod(dyn.Foo)"), Is.EqualTo(myClass.MyMethod(dyn.Foo)));
|
}
|
|
public class MyClass
|
{
|
public string MyMethod(string input)
|
{
|
return input;
|
}
|
}
|
|
public class TestDynamicClass : DynamicObject
|
{
|
public string RealProperty { get; set; }
|
|
public override DynamicMetaObject GetMetaObject(Expression parameter)
|
{
|
throw new Exception("This should not be called");
|
}
|
public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
|
{
|
throw new Exception("This should not be called");
|
}
|
public override bool TryGetMember(GetMemberBinder binder, out object result)
|
{
|
throw new Exception("This should not be called");
|
}
|
}
|
|
public class DynamicIndexAccess : DynamicObject
|
{
|
public dynamic Values
|
{
|
get
|
{
|
return _values;
|
}
|
}
|
private readonly IReadOnlyDictionary<string, object> _values;
|
|
public DynamicIndexAccess()
|
{
|
var values = new Dictionary<string, object>();
|
values.Add("Hello", "Hello World!");
|
_values = values;
|
}
|
|
public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
|
{
|
return _values.TryGetValue((string)indexes[0], out result);
|
}
|
|
public override bool TryGetMember(GetMemberBinder binder, out object result)
|
{
|
return _values.TryGetValue(binder.Name, out result);
|
}
|
}
|
}
|
}
|
