public void ConditionalIndex_Factory_Expression() { var obj = Expression.Constant(new S("foo")); var substring = PropertyInfoOf((S s) => s[default(int), default(int)]); var substringGet = substring.GetGetMethod(true); var args = new[] { Expression.Constant(1) }; foreach (var e in new[] { CSharpExpression.ConditionalIndex(obj, substring, args), CSharpExpression.ConditionalIndex(obj, substring, args.AsEnumerable()), }) { Assert.AreSame(obj, e.Object); Assert.AreEqual(1, e.Arguments.Count); Assert.AreEqual(substring.GetIndexParameters()[0], e.Arguments[0].Parameter); Assert.AreSame(args[0], e.Arguments[0].Expression); } foreach (var e in new[] { CSharpExpression.ConditionalIndex(obj, substringGet, args), CSharpExpression.ConditionalIndex(obj, substringGet, args.AsEnumerable()), }) { Assert.AreSame(obj, e.Object); Assert.AreEqual(1, e.Arguments.Count); Assert.AreEqual(substringGet.GetParameters()[0], e.Arguments[0].Parameter); Assert.AreSame(args[0], e.Arguments[0].Expression); } var tooLittle = new Expression[0]; foreach (var f in new Func <ConditionalIndexCSharpExpression>[] { () => CSharpExpression.ConditionalIndex(obj, substring, tooLittle), () => CSharpExpression.ConditionalIndex(obj, substring, tooLittle.AsEnumerable()), }) { AssertEx.Throws <ArgumentException>(() => f()); } var tooMany = new[] { Expression.Constant(1), Expression.Constant(2), Expression.Constant(3) }; foreach (var f in new Func <ConditionalIndexCSharpExpression>[] { () => CSharpExpression.ConditionalIndex(obj, substring, tooMany), () => CSharpExpression.ConditionalIndex(obj, substring, tooMany.AsEnumerable()), }) { AssertEx.Throws <ArgumentException>(() => f()); } }
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 ConditionalAccess_ManOrBoy1() { var p = Expression.Parameter(typeof(C)); var x = Expression.Constant(0); var F = p.Type.GetField("F"); var P = p.Type.GetProperty("P"); var I = p.Type.GetProperty("Item"); var M = p.Type.GetMethod("M"); var cF = (Func <Expression, Expression>)(e => CSharpExpression.ConditionalField(e, F)); var cP = (Func <Expression, Expression>)(e => CSharpExpression.ConditionalProperty(e, P)); var cI = (Func <Expression, Expression>)(e => CSharpExpression.ConditionalIndex(e, I, new[] { x })); var cM = (Func <Expression, Expression>)(e => CSharpExpression.ConditionalCall(e, M, new[] { x })); var cases = new Func <Expression, Expression>[][] { new[] { cF }, new[] { cF, cP }, new[] { cF, cP, cI }, new[] { cF, cP, cI, cM }, new[] { cM }, new[] { cM, cF }, new[] { cM, cF, cP }, new[] { cM, cF, cP, cI }, new[] { cI }, new[] { cI, cM }, new[] { cI, cM, cF }, new[] { cI, cM, cF, cP }, new[] { cP }, new[] { cP, cI }, new[] { cP, cI, cM }, new[] { cP, cI, cM, cF }, }; foreach (var cs in cases) { var e = cs.Aggregate((Expression)p, (a, b) => b(a)); var f = Expression.Lambda <Func <C, C> >(e, p).Compile(); Assert.IsNull(f(null)); for (var i = 0; i < cs.Length; i++) { Assert.IsNull(f(new C(i))); } Assert.IsNotNull(f(new C(cs.Length))); } }
public void ConditionalIndex_Factory_ArgumentChecking() { var expr = Expression.Default(typeof(Bar)); var other = Expression.Default(typeof(string)); var propName = "Item"; var propInfo = typeof(Bar).GetProperty(propName); var getInfo = propInfo.GetGetMethod(true); // null AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.ConditionalIndex(default(Expression), propInfo)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.ConditionalIndex(expr, default(PropertyInfo))); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.ConditionalIndex(default(Expression), getInfo)); AssertEx.Throws <ArgumentNullException>(() => CSharpExpression.ConditionalIndex(expr, default(MethodInfo))); // property - NB: this is allowed (and safe) in LINQ and it is here, too // AssertEx.Throws<ArgumentException>(() => CSharpExpression.ConditionalIndex(expr, expr.Type.GetProperty("P"))); // wrong declaring type AssertEx.Throws <ArgumentException>(() => CSharpExpression.ConditionalIndex(other, propInfo)); }
public void ConditionalIndex_Properties() { var item = PropertyInfoOf((Bar b) => b[default(int)]); var parameterp = item.GetIndexParameters()[0]; var getter = item.GetGetMethod(true); var parameterm = getter.GetParameters()[0]; var obj = Expression.Default(typeof(Bar)); var index = Expression.Constant(0); var argp = CSharpExpression.Bind(parameterp, index); var argm = CSharpExpression.Bind(parameterm, index); foreach (var e in new[] { CSharpExpression.ConditionalIndex(obj, item, argp), CSharpExpression.ConditionalIndex(obj, item, new[] { argp }.AsEnumerable()), }) { Assert.AreEqual(CSharpExpressionType.ConditionalAccess, e.CSharpNodeType); Assert.AreSame(obj, e.Object); Assert.AreEqual(item, e.Indexer); Assert.AreEqual(typeof(bool?), e.Type); Assert.IsTrue(e.Arguments.SequenceEqual(new[] { argp })); } foreach (var e in new[] { CSharpExpression.ConditionalIndex(obj, getter, argm), CSharpExpression.ConditionalIndex(obj, getter, new[] { argm }.AsEnumerable()) }) { Assert.AreEqual(CSharpExpressionType.ConditionalAccess, e.CSharpNodeType); Assert.AreSame(obj, e.Object); Assert.AreEqual(item, e.Indexer); Assert.AreEqual(typeof(bool?), e.Type); Assert.IsTrue(e.Arguments.SequenceEqual(new[] { argm })); } }