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 }));
}
}
