private static IEqualityComparer <Expression> GetExpressionHeapComparer()
{
var comparer = default(IEqualityComparer <Expression>);
var cache = new ExpressionHeap(ConstantHoister.Create(false), cmp => { comparer = cmp; return(new Cache <Expression>(new CacheStorage <Expression>(cmp))); });
return(comparer);
}
public void ExpressionHeap_Concurrency()
{
var exprs = new Expression[]
{
Expression.Parameter(typeof(int)),
Expression.Parameter(typeof(string), Guid.NewGuid().ToString()),
Expression.Parameter(typeof(long), "foo"),
Expression.Parameter(typeof(double), "foo"),
Expression.Default(typeof(int)),
#pragma warning disable IDE0004 // Remove Unnecessary Cast. (Makes the intent clear.)
(Expression <Func <int> >)(() => 42),
(Expression <Func <int, int> >)(x => x + 2),
(Expression <Func <double, int> >)(x => (int)Math.Round(x) + 2),
(Expression <Func <int[]> >)(() => new[] { 1, 2, 3 }),
(Expression <Func <string> >)(() => Tuple.Create(1, "foo").Item2),
#pragma warning restore IDE0004
};
var rand = new Random(17);
var tests = Enumerable.Repeat(exprs, 1000).SelectMany(x => x).OrderBy(_ => rand.Next());
var heap = new ExpressionHeap();
Parallel.ForEach(tests, e => AssertEqual(e, heap.Create(e).Value));
}
public void ExpressionHeap_Roundtrip()
{
var exprs = new Expression[]
{
Expression.Parameter(typeof(int)),
Expression.Parameter(typeof(string), Guid.NewGuid().ToString()),
Expression.Parameter(typeof(long), "foo"),
Expression.Parameter(typeof(double), "foo"),
Expression.Default(typeof(int)),
#pragma warning disable IDE0004 // Remove Unnecessary Cast. (Only unnecessary on C# 10 or later.)
(Expression <Func <int> >)(() => 42),
(Expression <Func <int, int> >)(x => x + 2),
(Expression <Func <double, int> >)(x => (int)Math.Round(x) + 2),
(Expression <Func <int[]> >)(() => new[] { 1, 2, 3 }),
(Expression <Func <string> >)(() => Tuple.Create(1, "foo").Item2),
#pragma warning restore IDE0004
};
var heap = new ExpressionHeap();
foreach (var expr in exprs)
{
AssertEqual(expr, heap.Create(expr).Value);
}
}
public void ExpressionPolicy_PropertyChecks()
{
var policy = new ExpressionPolicy();
Assert.AreSame(DefaultExpressionPolicy.Instance.DelegateCache, policy.DelegateCache);
Assert.AreSame(DefaultExpressionPolicy.Instance.InMemoryCache, policy.InMemoryCache);
Assert.AreSame(DefaultExpressionPolicy.Instance.ConstantHoister, policy.ConstantHoister);
var delegateCache = new SimpleCompiledDelegateCache();
var expressionCache = new ExpressionHeap();
var constantHoister = ConstantHoister.Create(false);
policy.DelegateCache = delegateCache;
policy.InMemoryCache = expressionCache;
policy.ConstantHoister = constantHoister;
Assert.AreSame(delegateCache, policy.DelegateCache);
Assert.AreSame(expressionCache, policy.InMemoryCache);
Assert.AreSame(constantHoister, policy.ConstantHoister);
policy.DelegateCache = null;
policy.InMemoryCache = null;
policy.ConstantHoister = null;
Assert.AreSame(DefaultExpressionPolicy.Instance.DelegateCache, policy.DelegateCache);
Assert.AreSame(DefaultExpressionPolicy.Instance.InMemoryCache, policy.InMemoryCache);
Assert.AreSame(DefaultExpressionPolicy.Instance.ConstantHoister, policy.ConstantHoister);
}
public void ExpressionHeap_ConstantExpression_ExpressionValue()
{
var innerExpr = Expression.Lambda(Expression.Default(typeof(string)));
var outerExpr = Expression.Constant(innerExpr);
var innerCopy = Expression.Lambda(Expression.Default(typeof(string)));
var heap = new ExpressionHeap();
var outerRef = heap.Create(outerExpr);
var copyRef = heap.Create(innerCopy);
Assert.AreSame(((ConstantExpression)outerRef.Value).Value, copyRef.Value);
}
public void ExpressionHeap_AssertSame()
{
var e1 = Expression.Lambda(Expression.Default(typeof(string)));
var e2 = Expression.Lambda(Expression.Default(typeof(string)));
Assert.AreNotSame(e1, e2);
var heap = new ExpressionHeap();
var r1 = heap.Create(e1);
var r2 = heap.Create(e2);
Assert.AreSame(r1.Value, r2.Value);
}
public void ExpressionHeap_DummyCacheStorage()
{
var e1 = Expression.Lambda(Expression.Default(typeof(string)));
var e2 = Expression.Lambda(Expression.Default(typeof(string)));
Assert.AreNotSame(e1, e2);
var heap = new ExpressionHeap(ConstantHoister.Create(false), _ => new Cache <Expression>(new DummyStorage()));
var r1 = heap.Create(e1);
var r2 = heap.Create(e2);
Assert.AreNotSame(r1.Value, r2.Value);
}
public void ExpressionHeap_CacheEqualityRegressionTest()
{
var cache = new ExpressionHeap();
Expression <Func <bool> > f1 = () => object.Equals(42, 7.0);
Expression <Func <bool> > f2 = () => object.Equals(7.0, 42);
Expression <Func <bool> > f3 = () => object.Equals(42, 7.0);
var r1 = cache.Create(f1);
var r2 = cache.Create(f2);
var r3 = cache.Create(f3);
var eqc = new ExpressionEqualityComparer();
Assert.IsTrue(eqc.Equals(f1, r1.Value));
Assert.IsTrue(eqc.Equals(f2, r2.Value));
Assert.IsTrue(eqc.Equals(f3, r3.Value));
}
public void ExpressionHeap_HoistedConstants_Shared()
{
var heap = new ExpressionHeap(ConstantHoister.Create(
false,
(Expression <Func <string, string> >)(c => string.Format(c, default(object)))));
Expression <Func <object, string> > f1 = x => string.Format("{0}", x);
Expression <Func <object, string> > f2 = x => string.Format("{0}", x);
Assert.AreNotSame(f1, f2);
var r1 = heap.Create(f1);
var r2 = heap.Create(f2);
var v1 = r1.Value;
var v2 = r2.Value;
Assert.AreSame(v1, v2);
}
public void ExpressionHeap_Roundtrip()
{
var exprs = new Expression[]
{
Expression.Parameter(typeof(int)),
Expression.Parameter(typeof(string), Guid.NewGuid().ToString()),
Expression.Parameter(typeof(long), "foo"),
Expression.Parameter(typeof(double), "foo"),
Expression.Default(typeof(int)),
(Expression <Func <int> >)(() => 42),
(Expression <Func <int, int> >)(x => x + 2),
(Expression <Func <double, int> >)(x => (int)Math.Round(x) + 2),
(Expression <Func <int[]> >)(() => new[] { 1, 2, 3 }),
(Expression <Func <string> >)(() => Tuple.Create(1, "foo").Item2),
};
var heap = new ExpressionHeap();
foreach (var expr in exprs)
{
AssertEqual(expr, heap.Create(expr).Value);
}
}
