public void Invoke_Compile2() { var invoke = MethodInfoOf((D f) => f.Invoke(default(int), default(int))); var parameters = invoke.GetParameters(); var parameterArg1 = parameters[0]; var parameterArg2 = parameters[1]; var valueArg1 = Expression.Constant(1); var valueArg2 = Expression.Constant(2); var function = Expression.Constant(new D((x, y) => x + y)); AssertCompile <int>(log => CSharpExpression.Invoke(log(function, "F"), CSharpExpression.Bind(parameterArg1, log(valueArg1, "1")), CSharpExpression.Bind(parameterArg2, log(valueArg2, "2")) ), new LogAndResult <int> { Value = 1 + 2, Log = { "F", "1", "2" } } ); AssertCompile <int>(log => CSharpExpression.Invoke(log(function, "F"), CSharpExpression.Bind(parameterArg1, log(valueArg1, "1")) ), new LogAndResult <int> { Value = 1 + 42, Log = { "F", "1" } } ); }
public void Index_Factory_CanUseMethod() { var substringMethod = MethodInfoOf((S s) => s[default(int), default(int)]); var substringProperty = PropertyInfoOf((S s) => s[default(int), default(int)]); var parameters = substringMethod.GetParameters(); var startIndexParameter = parameters[0]; var lengthParameter = parameters[1]; var obj = Expression.Constant(new S("foobar")); var startIndex = Expression.Constant(1); var length = Expression.Constant(2); var argStartIndex = CSharpExpression.Bind(startIndexParameter, startIndex); var argLength = CSharpExpression.Bind(lengthParameter, length); var expr1 = CSharpExpression.Index(obj, substringMethod, argStartIndex, argLength); Assert.AreEqual(substringProperty, expr1.Indexer); AssertCompile <string>(_ => expr1, new LogAndResult <string> { Value = "foobar".Substring(1, 2) }); var expr2 = CSharpExpression.Index(obj, substringMethod, new[] { argStartIndex, argLength }.AsEnumerable()); Assert.AreEqual(substringProperty, expr2.Indexer); AssertCompile <string>(_ => expr2, new LogAndResult <string> { Value = "foobar".Substring(1, 2) }); }
public void MethodCall_Compile_Instance() { var method = MethodInfoOf((string s) => s.Substring(default(int), default(int))); var parameters = method.GetParameters(); var parameterStartIndex = parameters[0]; var parameterLength = parameters[1]; var obj = Expression.Constant("foobar"); var valueStartIndex = Expression.Constant(1); var valueLength = Expression.Constant(2); AssertCompile <string>(log => CSharpExpression.Call(log(obj, "O"), method, CSharpExpression.Bind(parameterStartIndex, log(valueStartIndex, "S")), CSharpExpression.Bind(parameterLength, log(valueLength, "L")) ), new LogAndResult <string> { Value = "foobar".Substring(1, 2), Log = { "O", "S", "L" } } ); AssertCompile <string>(log => CSharpExpression.Call(log(obj, "O"), method, CSharpExpression.Bind(parameterLength, log(valueLength, "L")), CSharpExpression.Bind(parameterStartIndex, log(valueStartIndex, "S")) ), new LogAndResult <string> { Value = "foobar".Substring(1, 2), Log = { "O", "L", "S" } } ); }
public void MethodCall_Compile_ByRef_Array3() { var method = MethodInfoOf((int x) => int.TryParse("", out x)); var parameters = method.GetParameters(); var parameterX = parameters[0]; var parameterY = parameters[1]; var valueX = Expression.Constant("42"); var valueY = Expression.Parameter(typeof(int)); var array = Expression.Parameter(typeof(int[, ])); var newArray = Expression.Assign(array, Expression.NewArrayBounds(typeof(int), Expression.Constant(1), Expression.Constant(1))); var element = Expression.ArrayIndex(array, Expression.Constant(0), Expression.Constant(0)); AssertCompile <int>(log => Expression.Block(new[] { array }, newArray, CSharpExpression.Call(method, CSharpExpression.Bind(parameterY, element), CSharpExpression.Bind(parameterX, log(valueX, "S")) ), element ), new LogAndResult <int> { Value = 42, Log = { "S" } } ); }
public void ParameterAssignment_Properties() { var method = typeof(C).GetMethod("F"); var parameter = method.GetParameters()[0]; var expr = Expression.Constant(42); { var res = CSharpExpression.Bind(parameter, expr); Assert.AreSame(parameter, res.Parameter); Assert.AreSame(expr, res.Expression); } { var res = CSharpExpression.Bind(method, parameter.Name, expr); Assert.AreSame(parameter, res.Parameter); Assert.AreSame(expr, res.Expression); } { var res = CSharpExpression.Bind(method, 0, expr); Assert.AreSame(parameter, res.Parameter); Assert.AreSame(expr, res.Expression); } }
public void New_Update() { var ctor = ConstructorInfoOf(() => new TimeSpan(default(int), default(int), default(int))); var parameters = ctor.GetParameters(); var hoursParameter = parameters[0]; var minutesParameter = parameters[1]; var secondsParameter = parameters[2]; var hours = Expression.Constant(1); var minutes = Expression.Constant(2); var seconds = Expression.Constant(3); var arg0 = CSharpExpression.Bind(hoursParameter, hours); var arg1 = CSharpExpression.Bind(minutesParameter, minutes); var arg2 = CSharpExpression.Bind(secondsParameter, seconds); var res = CSharpExpression.New(ctor, arg0, arg1, arg2); var upd1 = res.Update(res.Arguments); Assert.AreSame(upd1, res); var upd2 = res.Update(new[] { arg1, arg0, arg2 }); Assert.AreNotSame(upd2, res); Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg1, arg0, arg2 })); }
public void ConditionalCall_Compile_Extension() { var reverse = MethodInfoOf(() => Ext.Reverse(default(string))); var reverseSubstring = MethodInfoOf(() => Ext.ReverseSubstring(default(string), default(int), default(int))); var p = Expression.Parameter(typeof(string)); var q = "foobar"; var m1 = CSharpExpression.ConditionalCall(p, reverse); var f1 = Expression.Lambda <Func <string, string> >(m1, p); var d1 = f1.Compile(); Assert.AreEqual("raboof", d1(q)); Assert.IsNull(d1(null)); var m2 = CSharpExpression.ConditionalCall(p, reverseSubstring, new[] { Expression.Constant(2), Expression.Constant(3) }); var f2 = Expression.Lambda <Func <string, string> >(m2, p); var d2 = f2.Compile(); Assert.AreEqual("abo", d2(q)); Assert.IsNull(d2(null)); var ps = reverseSubstring.GetParameters(); var m3 = CSharpExpression.ConditionalCall(p, reverseSubstring, CSharpExpression.Bind(ps[2], Expression.Constant(3)), CSharpExpression.Bind(ps[1], Expression.Constant(2))); var f3 = Expression.Lambda <Func <string, string> >(m3, p); var d3 = f3.Compile(); Assert.AreEqual("abo", d3(q)); Assert.IsNull(d3(null)); }
public void ParameterAssignment_Factory_ArgumentChecking() { var method = typeof(C).GetMethod("F"); var parameter = method.GetParameters()[0]; var name = parameter.Name; var expr = Expression.Constant(42); // null AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(default(ParameterInfo), expr)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(parameter, default(Expression))); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(default(MethodInfo), name, expr)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(method, default(string), expr)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(method, name, default(Expression))); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(default(MethodInfo), 0, expr)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Bind(method, 0, default(Expression))); // can't find AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(method, "y", expr)); AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(method, -1, expr)); AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(method, 1, expr)); AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(method, 2, expr)); // type mismatch AssertEx.Throws <ArgumentException>(() => CSharpExpression.Bind(parameter, Expression.Constant("bar"))); }
public void ConditionalCall_Update() { var baz = MethodInfoOf((Bar b) => b.Baz(default(int))); var parameter = baz.GetParameters()[0]; var obj = Expression.Default(typeof(Bar)); var value = Expression.Constant(0); var arg = CSharpExpression.Bind(parameter, value); var res = CSharpExpression.ConditionalCall(obj, baz, arg); Assert.AreSame(res, res.Update(res.Object, res.Arguments)); var obj1 = Expression.Default(typeof(Bar)); var upd1 = res.Update(obj1, res.Arguments); Assert.AreNotSame(upd1, res); Assert.AreSame(res.Arguments, upd1.Arguments); Assert.AreSame(obj1, upd1.Object); var upd2 = res.Update(obj, new[] { arg }); Assert.AreNotSame(upd2, res); Assert.AreSame(res.Object, upd2.Object); Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg })); }
public void ConditionalIndex_Compile_Val() { var px = Expression.Parameter(typeof(QuzX?)); var qx = new QuzX(); var ix = typeof(QuzX).GetProperty("Item"); var ax = CSharpExpression.Bind(ix.GetIndexParameters()[0], Expression.Constant(0)); var mx = CSharpExpression.ConditionalIndex(px, ix, ax); var fx = Expression.Lambda <Func <QuzX?, int?> >(mx, px); var dx = fx.Compile(); Assert.AreEqual(42, dx(qx)); Assert.IsNull(dx(null)); var pn = Expression.Parameter(typeof(QuzN?)); var qn = new QuzN(); var jn = typeof(QuzN).GetProperty("Item"); var an = CSharpExpression.Bind(jn.GetIndexParameters()[0], Expression.Constant(0)); var mn = CSharpExpression.ConditionalIndex(pn, jn, an); var fn = Expression.Lambda <Func <QuzN?, int?> >(mn, pn); var dn = fn.Compile(); Assert.AreEqual(42, dn(qn)); Assert.IsNull(dn(null)); var ps = Expression.Parameter(typeof(QuzS?)); var qs = new QuzS(); var js = typeof(QuzS).GetProperty("Item"); var bs = CSharpExpression.Bind(js.GetIndexParameters()[0], Expression.Constant(0)); var ms = CSharpExpression.ConditionalIndex(ps, js, bs); var fs = Expression.Lambda <Func <QuzS?, string> >(ms, ps); var ds = fs.Compile(); Assert.AreEqual("bar", ds(qs)); Assert.IsNull(ds(null)); }
public void ConditionalIndex_Update() { var item = PropertyInfoOf((Bar b) => b[default(int)]); var parameters = item.GetIndexParameters(); var parameter = parameters[0]; var obj = Expression.Default(typeof(Bar)); var index = Expression.Constant(0); var arg = CSharpExpression.Bind(parameter, index); var res = CSharpExpression.ConditionalIndex(obj, item, arg); Assert.AreSame(res, res.Update(res.Object, res.Arguments)); var obj1 = Expression.Default(typeof(Bar)); var upd1 = res.Update(obj1, res.Arguments); Assert.AreNotSame(upd1, res); Assert.AreSame(res.Arguments, upd1.Arguments); Assert.AreSame(obj1, upd1.Object); var upd2 = res.Update(obj, new[] { arg }); Assert.AreNotSame(upd2, res); Assert.AreSame(res.Object, upd2.Object); Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg })); }
public void Invoke_Properties() { var invoke = MethodInfoOf((Func <int, int, int> f) => f.Invoke(default(int), default(int))); var parameters = invoke.GetParameters(); var arg1Parameter = parameters[0]; var arg2Parameter = parameters[1]; var arg1Value = Expression.Constant(0); var arg2Value = Expression.Constant(1); var arg0 = CSharpExpression.Bind(arg1Parameter, arg1Value); var arg1 = CSharpExpression.Bind(arg2Parameter, arg2Value); var function = Expression.Constant(new Func <int, int, int>((x, y) => x + y)); { var res = CSharpExpression.Invoke(function, arg0, arg1); Assert.AreEqual(CSharpExpressionType.Invoke, res.CSharpNodeType); Assert.AreSame(function, res.Expression); Assert.AreEqual(typeof(int), res.Type); Assert.IsTrue(res.Arguments.SequenceEqual(new[] { arg0, arg1 })); } { var res = CSharpExpression.Invoke(function, new[] { arg0, arg1 }.AsEnumerable()); Assert.AreEqual(CSharpExpressionType.Invoke, res.CSharpNodeType); Assert.AreSame(function, res.Expression); Assert.AreEqual(typeof(int), res.Type); Assert.IsTrue(res.Arguments.SequenceEqual(new[] { arg0, arg1 })); } }
public void Invoke_Update() { var invoke = MethodInfoOf((Func <int, int, int> f) => f.Invoke(default(int), default(int))); var parameters = invoke.GetParameters(); var arg1Parameter = parameters[0]; var arg2Parameter = parameters[1]; var arg1Value = Expression.Constant(0); var arg2Value = Expression.Constant(1); var arg0 = CSharpExpression.Bind(arg1Parameter, arg1Value); var arg1 = CSharpExpression.Bind(arg2Parameter, arg2Value); var function = Expression.Constant(new Func <int, int, int>((x, y) => x + y)); var res = CSharpExpression.Invoke(function, arg0, arg1); var function1 = Expression.Constant(new Func <int, int, int>((x, y) => x + y)); var upd1 = res.Update(function1, res.Arguments); Assert.AreNotSame(upd1, res); Assert.AreSame(res.Arguments, upd1.Arguments); Assert.AreSame(function1, upd1.Expression); var upd2 = res.Update(function, new[] { arg1, arg0 }); Assert.AreNotSame(upd2, res); Assert.AreSame(res.Expression, upd2.Expression); Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg1, arg0 })); }
public void MethodCall_Compile_ByRef_Property() { var method = MethodInfoOf((int x) => int.TryParse("", out x)); var parameters = method.GetParameters(); var parameterX = parameters[0]; var parameterY = parameters[1]; var valueX = Expression.Constant("42"); var valueY = Expression.Parameter(typeof(int)); var box = Expression.Parameter(typeof(MyBox <int>)); var newBox = Expression.Assign(box, Expression.New(box.Type)); var boxValue = Expression.Property(box, "Value"); AssertCompile <int>(log => Expression.Block(new[] { box }, newBox, CSharpExpression.Call(method, CSharpExpression.Bind(parameterY, boxValue), CSharpExpression.Bind(parameterX, log(valueX, "S")) ), boxValue ), new LogAndResult <int> { Value = 42, Log = { "S" } } ); }
public void MethodCall_Compile_ByRef_Index() { var method = MethodInfoOf((int x) => int.TryParse("", out x)); var parameters = method.GetParameters(); var parameterX = parameters[0]; var parameterY = parameters[1]; var valueX = Expression.Constant("42"); var valueY = Expression.Parameter(typeof(int)); var list = Expression.Parameter(typeof(List <int>)); var newList = Expression.Assign(list, Expression.ListInit(Expression.New(typeof(List <int>)), Expression.Constant(1))); var element = Expression.MakeIndex(list, typeof(List <int>).GetProperty("Item"), new[] { Expression.Constant(0) }); AssertCompile <int>(log => Expression.Block(new[] { list }, newList, CSharpExpression.Call(method, CSharpExpression.Bind(parameterY, element), CSharpExpression.Bind(parameterX, log(valueX, "S")) ), element ), new LogAndResult <int> { Value = 42, Log = { "S" } } ); }
public void MethodCall_Update() { var substring = MethodInfoOf((string s) => s.Substring(default(int), default(int))); var parameters = substring.GetParameters(); var startIndexParameter = parameters[0]; var lengthParameter = parameters[1]; var obj = Expression.Constant("bar"); var startIndex = Expression.Constant(0); var length = Expression.Constant(1); var arg0 = CSharpExpression.Bind(startIndexParameter, startIndex); var arg1 = CSharpExpression.Bind(lengthParameter, length); var res = CSharpExpression.Call(obj, substring, arg0, arg1); Assert.AreSame(res, res.Update(res.Object, res.Arguments)); var obj1 = Expression.Constant("foo"); var upd1 = res.Update(obj1, res.Arguments); Assert.AreNotSame(upd1, res); Assert.AreSame(res.Arguments, upd1.Arguments); Assert.AreSame(obj1, upd1.Object); var upd2 = res.Update(obj, new[] { arg1, arg0 }); Assert.AreNotSame(upd2, res); Assert.AreSame(res.Object, upd2.Object); Assert.IsTrue(upd2.Arguments.SequenceEqual(new[] { arg1, arg0 })); }
public void MethodCall_Properties_Static() { var min = MethodInfoOf(() => Math.Min(default(int), default(int))); var parameters = min.GetParameters(); var val1Parameter = parameters[0]; var val2Parameter = parameters[1]; var val1 = Expression.Constant(0); var val2 = Expression.Constant(1); var arg0 = CSharpExpression.Bind(val1Parameter, val1); var arg1 = CSharpExpression.Bind(val2Parameter, val2); { var res = CSharpExpression.Call(min, arg0, arg1); Assert.AreEqual(CSharpExpressionType.Call, res.CSharpNodeType); Assert.IsNull(res.Object); Assert.AreEqual(min, res.Method); Assert.AreEqual(typeof(int), res.Type); Assert.IsTrue(res.Arguments.SequenceEqual(new[] { arg0, arg1 })); } { var res = CSharpExpression.Call(min, new[] { arg0, arg1 }.AsEnumerable()); Assert.AreEqual(CSharpExpressionType.Call, res.CSharpNodeType); Assert.IsNull(res.Object); Assert.AreEqual(min, res.Method); Assert.AreEqual(typeof(int), res.Type); Assert.IsTrue(res.Arguments.SequenceEqual(new[] { arg0, arg1 })); } }
public void AssignUnary_CSharpIndex_Compile() { var toString = MethodInfoOf((int a) => a.ToString()); foreach (var n in new[] { CSharpExpressionType.PreIncrementAssign, CSharpExpressionType.PreIncrementAssignChecked, CSharpExpressionType.PreDecrementAssign, CSharpExpressionType.PreDecrementAssignChecked, CSharpExpressionType.PostIncrementAssign, CSharpExpressionType.PostIncrementAssignChecked, CSharpExpressionType.PostDecrementAssign, CSharpExpressionType.PostDecrementAssignChecked, }) { var inc = n.ToString().Contains("Inc"); var pre = n.ToString().Contains("Pre"); var exp = new string[2]; exp[0] = inc ? "42" : "40"; exp[1] = pre ? exp[0] : "41"; AssertCompile((log, append) => { var h = Expression.Parameter(typeof(Holder <int>)); var y = Expression.Parameter(typeof(int)); var item = typeof(Holder <int>).GetProperty("Item"); var pars = item.GetIndexParameters(); var index = CSharpExpression.Index( h, item, new[] { CSharpExpression.Bind(pars[1], Expression.Block(log("I1"), Expression.Constant(2))), CSharpExpression.Bind(pars[0], Expression.Block(log("I2"), Expression.Constant(1))), } ); var field = Expression.Field(h, typeof(Holder <int>).GetField("_value")); return (Expression.Block( new[] { h, y }, Expression.Assign(h, Expression.New(h.Type.GetConstructors()[0], append, Expression.Constant(41))), Expression.Assign(y, CSharpExpression.MakeUnaryAssign(n, index, null)), Expression.Invoke(append, Expression.Call(field, toString)), Expression.Invoke(append, Expression.Call(y, toString)) )); }, new LogAndResult <object> { Log = { "I1", "I2", "GI", "SI", exp[0], exp[1] } }); } }
public void MethodCall_Compile_Static() { var method = MethodInfoOf(() => F(default(int), default(int), default(int))); var parameters = method.GetParameters(); var parameterX = parameters[0]; var parameterY = parameters[1]; var parameterZ = parameters[2]; var valueX = Expression.Constant(1); var valueY = Expression.Constant(2); var valueZ = Expression.Constant(3); AssertCompile <int>(log => CSharpExpression.Call(method, CSharpExpression.Bind(parameterX, log(valueX, "X")), CSharpExpression.Bind(parameterY, log(valueY, "Y")) ), new LogAndResult <int> { Value = F(1, 2), Log = { "X", "Y" } } ); AssertCompile <int>(log => CSharpExpression.Call(method, CSharpExpression.Bind(parameterY, log(valueY, "Y")), CSharpExpression.Bind(parameterX, log(valueX, "X")) ), new LogAndResult <int> { Value = F(1, 2), Log = { "Y", "X" } } ); AssertCompile <int>(log => CSharpExpression.Call(method, CSharpExpression.Bind(parameterY, log(valueY, "Y")), CSharpExpression.Bind(parameterX, log(valueX, "X")), CSharpExpression.Bind(parameterZ, log(valueZ, "Z")) ), new LogAndResult <int> { Value = F(1, 2, 3), Log = { "Y", "X", "Z" } } ); AssertCompile <int>(log => CSharpExpression.Call(method, CSharpExpression.Bind(parameterX, log(valueX, "X")), CSharpExpression.Bind(parameterY, log(valueY, "Y")), CSharpExpression.Bind(parameterZ, log(valueZ, "Z")) ), new LogAndResult <int> { Value = F(1, 2, 3), Log = { "X", "Y", "Z" } } ); }
public void MethodCall_Visitor() { var cout = MethodInfoOf(() => Console.WriteLine(default(int))); var valueParameter = cout.GetParameters()[0]; var value = Expression.Constant(42); var res = CSharpExpression.Call(cout, CSharpExpression.Bind(valueParameter, value)); var v = new V(); Assert.AreSame(res, v.Visit(res)); Assert.IsTrue(v.Visited); }
public void ParameterAssignment_Factory_CanQuote() { var where = MethodInfoOf(() => Queryable.Where(default(IQueryable <int>), default(Expression <Func <int, bool> >))); var filterParameter = where.GetParameters()[1]; var filter = (Expression <Func <int, bool> >)(i => i < 0); var res = CSharpExpression.Bind(filterParameter, filter); Assert.AreEqual(ExpressionType.Quote, res.Expression.NodeType); Assert.AreSame(filter, ((UnaryExpression)res.Expression).Operand); }
public void New_Visitor() { var ctor = ConstructorInfoOf(() => new TimeSpan(default(long))); var valueParameter = ctor.GetParameters()[0]; var value = Expression.Constant(42L); var res = CSharpExpression.New(ctor, CSharpExpression.Bind(valueParameter, value)); var v = new V(); Assert.AreSame(res, v.Visit(res)); Assert.IsTrue(v.Visited); }
public void ParameterAssignment_Factory_SupportByRef() { var exchange = MethodInfoOf((int x) => Interlocked.Exchange(ref x, x)); var refParameter = exchange.GetParameters()[0]; var expr = Expression.Parameter(typeof(int)); var res = CSharpExpression.Bind(refParameter, expr); Assert.AreSame(refParameter, res.Parameter); Assert.AreSame(expr, res.Expression); }
public void Index_Visitor() { var listIndex = PropertyInfoOf((List <int> xs) => xs[default(int)]); var valueParameter = listIndex.GetIndexParameters()[0]; var list = Expression.Constant(new List <int>()); var value = Expression.Constant(42); var res = CSharpExpression.Index(list, listIndex, CSharpExpression.Bind(valueParameter, value)); var v = new V(); Assert.AreSame(res, v.Visit(res)); Assert.IsTrue(v.Visited); }
public void ParameterAssignment_Visitor() { var method = typeof(C).GetMethod("F"); var parameter = method.GetParameters()[0]; var expr = Expression.Constant(42); var bind = CSharpExpression.Bind(parameter, expr); var res = CSharpExpression.Call(method, bind); var v = new V(); Assert.AreSame(res, v.Visit(res)); Assert.IsTrue(v.Visited); }
public void MethodCall_Compile_ByRef_MutableStruct2() { var y = default(int); var method = MethodInfoOf((S s) => s.F(default(int), ref y)); var parameters = method.GetParameters(); var parameterX = parameters[0]; var parameterY = parameters[1]; var valueX = Expression.Constant(12); var valueY = Expression.Parameter(typeof(int)); var value = Expression.Parameter(typeof(StrongBox <S>)); var prop = Expression.Field(value, "Value"); var newValue = Expression.Assign(value, Expression.New(typeof(StrongBox <S>))); var valueZ = Expression.Field(prop, "Z"); AssertCompile <int>(log => Expression.Block(new[] { value, valueY }, newValue, Expression.Assign(valueY, Expression.Constant(30)), CSharpExpression.Call(prop, method, CSharpExpression.Bind(parameterX, valueX), CSharpExpression.Bind(parameterY, valueY) ), Expression.Subtract(valueZ, valueY) ), new LogAndResult <int> { Value = 0 } ); AssertCompile <int>(log => Expression.Block(new[] { value, valueY }, newValue, Expression.Assign(valueY, Expression.Constant(30)), CSharpExpression.Call(prop, method, CSharpExpression.Bind(parameterY, valueY), CSharpExpression.Bind(parameterX, valueX) ), Expression.Subtract(valueZ, valueY) ), new LogAndResult <int> { Value = 0 } ); }
public void ParameterAssignment_Update() { var method = typeof(C).GetMethod("F"); var parameter = method.GetParameters()[0]; var expr = Expression.Constant(42); var res = CSharpExpression.Bind(parameter, expr); Assert.AreSame(res, res.Update(res.Expression)); var rev = Expression.Constant(43); var upd = res.Update(rev); Assert.AreNotSame(res, upd); Assert.AreSame(rev, upd.Expression); }
public void New_Factory_ArgumentChecking() { // NB: A lot of checks are performed by LINQ helpers, so we omit tests for those cases. var ctor = ConstructorInfoOf(() => new TimeSpan(default(int), default(int), default(int))); var parameters = ctor.GetParameters(); var hoursParameter = parameters[0]; var minutesParameter = parameters[1]; var secondsParameter = parameters[2]; var hours = Expression.Constant(1); var minutes = Expression.Constant(2); var seconds = Expression.Constant(3); var argHours = CSharpExpression.Bind(hoursParameter, hours); var argMinutes = CSharpExpression.Bind(minutesParameter, minutes); var argSeconds = CSharpExpression.Bind(secondsParameter, seconds); var ticks = ConstructorInfoOf(() => new TimeSpan(default(long))); var ticksParameter = ticks.GetParameters()[0]; var value = Expression.Constant(42L); var argTicks = CSharpExpression.Bind(ticksParameter, value); // duplicate AssertEx.Throws <ArgumentException>(() => CSharpExpression.New(ctor, argHours, argHours)); // unbound AssertEx.Throws <ArgumentException>(() => CSharpExpression.New(ctor, argHours)); // wrong member AssertEx.Throws <ArgumentException>(() => CSharpExpression.New(ctor, argTicks)); // null var bindings = new[] { argHours, argMinutes }; AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.New(default(ConstructorInfo), bindings)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.New(default(ConstructorInfo), bindings.AsEnumerable())); // static ctor var cctor = typeof(S).GetConstructors(BindingFlags.Static | BindingFlags.NonPublic).Single(c => c.IsStatic); AssertEx.Throws <ArgumentException>(() => CSharpExpression.New(cctor)); }
public void Index_Factory_ArgumentChecking() { // NB: A lot of checks are performed by LINQ helpers, so we omit tests for those cases. var substring = PropertyInfoOf((S s) => s[default(int), default(int)]); var parameters = substring.GetIndexParameters(); var startIndexParameter = parameters[0]; var lengthParameter = parameters[1]; var obj = Expression.Constant(new S("bar")); var startIndex = Expression.Constant(0); var length = Expression.Constant(1); var argStartIndex = CSharpExpression.Bind(startIndexParameter, startIndex); var argLength = CSharpExpression.Bind(lengthParameter, length); var listIndex = PropertyInfoOf((List <int> xs) => xs[default(int)]); var valueParameter = listIndex.GetIndexParameters()[0]; var value = Expression.Constant(42); var argValue = CSharpExpression.Bind(valueParameter, value); // duplicate AssertEx.Throws <ArgumentException>(() => CSharpExpression.Index(obj, substring, argStartIndex, argStartIndex)); // unbound AssertEx.Throws <ArgumentException>(() => CSharpExpression.Index(obj, substring, argLength)); // wrong member AssertEx.Throws <ArgumentException>(() => CSharpExpression.Index(obj, substring, argValue)); // null var bindings = new[] { argStartIndex, argLength }; AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Index(default(Expression), substring, bindings)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Index(default(Expression), substring, bindings.AsEnumerable())); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Index(obj, default(PropertyInfo), bindings)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Index(obj, default(PropertyInfo), bindings.AsEnumerable())); // only setter AssertEx.Throws <ArgumentException>(() => CSharpExpression.Index(Expression.Default(typeof(X)), typeof(X).GetProperty("Item"))); }
public void MethodCall_Factory_ArgumentChecking() { // NB: A lot of checks are performed by LINQ helpers, so we omit tests for those cases. var substring = MethodInfoOf((string s) => s.Substring(default(int), default(int))); var parameters = substring.GetParameters(); var startIndexParameter = parameters[0]; var lengthParameter = parameters[1]; var obj = Expression.Constant("bar"); var startIndex = Expression.Constant(0); var length = Expression.Constant(1); var argStartIndex = CSharpExpression.Bind(startIndexParameter, startIndex); var argLength = CSharpExpression.Bind(lengthParameter, length); var cout = MethodInfoOf(() => Console.WriteLine(default(int))); var valueParameter = cout.GetParameters()[0]; var value = Expression.Constant(42); var argValue = CSharpExpression.Bind(valueParameter, value); // duplicate AssertEx.Throws <ArgumentException>(() => CSharpExpression.Call(obj, substring, argStartIndex, argStartIndex)); // unbound AssertEx.Throws <ArgumentException>(() => CSharpExpression.Call(obj, substring, argStartIndex)); // wrong member AssertEx.Throws <ArgumentException>(() => CSharpExpression.Call(obj, substring, argValue)); // null var bindings = new[] { argStartIndex, argLength }; AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Call(default(MethodInfo), bindings)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Call(default(MethodInfo), bindings.AsEnumerable())); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Call(obj, default(MethodInfo), bindings)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.Call(obj, default(MethodInfo), bindings.AsEnumerable())); }