protected internal override QueryOperator VisitTake(TakeOperator op)
{
var o = (TakeOperator)base.VisitTake(op);
var m = op.QueryExpressionFactory.Take(o.ElementType, o.Source, o.Count);
return(m);
}
public void QueryExpressionToStringTests_Simple()
{
var visitor = new QueryDebugger();
var type = typeof(int);
var lambdaAbstraction = DefaultQueryExpressionFactory.Instance.LambdaAbstraction(Expression.Lambda(Expression.Default(typeof(IEnumerable <int>))));
var lambdaAbstractionPredicate = DefaultQueryExpressionFactory.Instance.LambdaAbstraction((Expression <Func <Func <int, bool> > >)(() => _ => true));
var lambdaAbstractionSelector = DefaultQueryExpressionFactory.Instance.LambdaAbstraction((Expression <Func <Func <int, int> > >)(() => _ => _));
#pragma warning disable IDE0004 // Remove Unnecessary Cast. (Only unnecessary on C# 10 or later.)
var lambdaAbstractionCount = DefaultQueryExpressionFactory.Instance.LambdaAbstraction((Expression <Func <int> >)(() => 42));
#pragma warning restore IDE0004 // Remove Unnecessary Cast
var monadMember = (MonadMember) new MonadAbstraction(type, lambdaAbstraction);
{
var op = new FirstOperator(type, monadMember);
Assert.AreEqual("@First(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))))", visitor.Visit(op));
}
{
var op = new FirstPredicateOperator(type, monadMember, lambdaAbstractionPredicate);
Assert.AreEqual("@First(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))), @LambdaAbstraction(() => _ => True))", visitor.Visit(op));
}
{
var op = new SelectOperator(type, type, monadMember, lambdaAbstractionSelector);
Assert.AreEqual("@Select(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))), @LambdaAbstraction(() => _ => _))", visitor.Visit(op));
}
{
var op = new TakeOperator(type, monadMember, lambdaAbstractionCount);
Assert.AreEqual("@Take(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))), @LambdaAbstraction(() => 42))", visitor.Visit(op));
}
{
var op = new WhereOperator(type, monadMember, lambdaAbstractionPredicate);
Assert.AreEqual("@Where(@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))), @LambdaAbstraction(() => _ => True))", visitor.Visit(op));
}
{
var ma = new MonadAbstraction(type, lambdaAbstraction);
Assert.AreEqual("@MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1)))", visitor.Visit(ma));
}
{
var lambda = Expression.Lambda(Expression.Default(typeof(int)), Expression.Parameter(typeof(IEnumerable <int>), "p"));
var parameters = new QueryTree[] { monadMember }.ToReadOnly();
var la = new LambdaAbstraction(lambda, parameters);
Assert.AreEqual("@LambdaAbstraction(p => default(Int32), @MonadAbstraction(@LambdaAbstraction(() => default(IEnumerable`1))))", visitor.Visit(la));
}
}
public int GetHashCode(TakeOperator obj)
{
return(GetHashCodeTake(obj));
}
public bool Equals(TakeOperator x, TakeOperator y)
{
return(EqualsTake(x, y));
}
public void QueryExpressionEqualityComparer_Simple()
{
var type1 = typeof(int);
var type2 = typeof(bool);
var monadMember1 = (MonadMember) new MonadAbstraction(type1, inner: null);
var monadMember2 = (MonadMember) new MonadAbstraction(type2, inner: null);
var lambdaAbstraction1 = new LambdaAbstraction(Expression.Lambda(Expression.Constant(42)), EmptyReadOnlyCollection <QueryTree> .Instance);
var lambdaAbstraction2 = new LambdaAbstraction(Expression.Lambda(Expression.Empty()), EmptyReadOnlyCollection <QueryTree> .Instance);
foreach (dynamic comparer in new object[] {
new QueryExpressionEqualityComparer(),
new QueryExpressionEqualityComparator(),
new QueryTreeDerivedClassEqualityComparer()
})
{
{
var op = new FirstOperator(type1, monadMember1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new FirstOperator(type1, monadMember1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new FirstOperator(type2, monadMember1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new FirstOperator(type1, monadMember2);
Assert.IsFalse(comparer.Equals(op, op4));
}
{
var op = new FirstPredicateOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new FirstPredicateOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new FirstPredicateOperator(type2, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new FirstPredicateOperator(type1, monadMember2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new FirstPredicateOperator(type1, monadMember1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op5));
}
{
var type3 = typeof(long);
var type4 = typeof(double);
var op = new SelectOperator(type1, type3, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new SelectOperator(type1, type3, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new SelectOperator(type2, type3, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new SelectOperator(type2, type4, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new SelectOperator(type1, type3, monadMember2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op5));
var op6 = new SelectOperator(type1, type3, monadMember1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op6));
}
{
var op = new TakeOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new TakeOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new TakeOperator(type2, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new TakeOperator(type1, monadMember2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new TakeOperator(type1, monadMember1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op5));
}
{
var op = new WhereOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new WhereOperator(type1, monadMember1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new WhereOperator(type2, monadMember1, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new WhereOperator(type1, monadMember2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new WhereOperator(type1, monadMember1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op5));
}
{
var op = new MonadAbstraction(type1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new MonadAbstraction(type1, lambdaAbstraction1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new MonadAbstraction(type2, lambdaAbstraction1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new MonadAbstraction(type1, lambdaAbstraction2);
Assert.IsFalse(comparer.Equals(op, op4));
}
{
var p1 = Expression.Parameter(type1);
var p2 = Expression.Parameter(type2);
var lambda1 = Expression.Lambda(p1, p1);
var lambda2 = Expression.Lambda(Expression.Constant(41), p2);
var lambda3 = Expression.Lambda(p2, p2);
var parameters1 = new QueryTree[] { monadMember1 }.ToReadOnly();
var parameters2 = new QueryTree[] { monadMember2 }.ToReadOnly();
var op = new LambdaAbstraction(lambda1, parameters1);
Assert.IsTrue(comparer.Equals(op, op));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op));
var op2 = new LambdaAbstraction(lambda1, parameters1);
Assert.IsTrue(comparer.Equals(op, op2));
Assert.AreEqual(comparer.GetHashCode(op), comparer.GetHashCode(op2));
var op3 = new LambdaAbstraction(lambda2, parameters1);
Assert.IsFalse(comparer.Equals(op, op3));
var op4 = new LambdaAbstraction(lambda1, parameters2);
Assert.IsFalse(comparer.Equals(op, op4));
var op5 = new LambdaAbstraction(lambda3, parameters1);
Assert.IsTrue(comparer.Equals(op, op5));
}
{
var op = new FirstOperator(type1, monadMember1);
Assert.IsFalse(comparer.Equals(op, lambdaAbstraction1));
}
}
}
public void QueryExpressionEqualityComparer_NullArguments()
{
foreach (dynamic comparer in new object[] {
new QueryExpressionEqualityComparer(),
new QueryExpressionEqualityComparator(),
new QueryTreeDerivedClassEqualityComparer()
})
{
var type1 = typeof(int);
var type2 = typeof(bool);
var monadMember1 = (MonadMember) new MonadAbstraction(type1, inner: null);
var lambdaAbstraction1 = new LambdaAbstraction(Expression.Lambda(Expression.Constant(42)), EmptyReadOnlyCollection <QueryTree> .Instance);
{
var op = new FirstOperator(type1, monadMember1);
var nul = default(FirstOperator);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
Assert.AreEqual(17, comparer.GetHashCode(nul));
}
{
var op = new MonadAbstraction(type1, new FirstOperator(type1, monadMember1));
var nul = new MonadAbstraction(type1, inner: null);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
}
{
var op = new FirstPredicateOperator(type1, monadMember1, lambdaAbstraction1);
var nul = default(FirstPredicateOperator);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
Assert.AreEqual(17, comparer.GetHashCode(nul));
}
{
var op = new MonadAbstraction(type1, new FirstPredicateOperator(type1, monadMember1, lambdaAbstraction1));
var nul = new MonadAbstraction(type1, inner: null);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
}
{
var op = new SelectOperator(type1, type2, monadMember1, lambdaAbstraction1);
var nul = default(SelectOperator);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
Assert.AreEqual(17, comparer.GetHashCode(nul));
}
{
var op = new MonadAbstraction(type1, new SelectOperator(type1, type2, monadMember1, lambdaAbstraction1));
var nul = new MonadAbstraction(type1, inner: null);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
}
{
var op = new TakeOperator(type1, monadMember1, lambdaAbstraction1);
var nul = default(TakeOperator);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
Assert.AreEqual(17, comparer.GetHashCode(nul));
}
{
var op = new MonadAbstraction(type1, new TakeOperator(type1, monadMember1, lambdaAbstraction1));
var nul = new MonadAbstraction(type1, inner: null);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
}
{
var op = new WhereOperator(type1, monadMember1, lambdaAbstraction1);
var nul = default(WhereOperator);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
Assert.AreEqual(17, comparer.GetHashCode(nul));
}
{
var op = new MonadAbstraction(type1, new WhereOperator(type1, monadMember1, lambdaAbstraction1));
var nul = new MonadAbstraction(type1, inner: null);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
}
{
var op = new MonadAbstraction(type1, lambdaAbstraction1);
var nul = default(MonadAbstraction);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
Assert.AreEqual(17, comparer.GetHashCode(nul));
}
{
var op = new MonadAbstraction(type2, new MonadAbstraction(type1, lambdaAbstraction1));
var nul = new MonadAbstraction(type2, inner: null);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
}
{
var op = new LambdaAbstraction(Expression.Lambda(Expression.Constant(41), Expression.Parameter(type1)), new QueryTree[] { lambdaAbstraction1 }.ToReadOnly());
var nul = default(LambdaAbstraction);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
Assert.AreEqual(17, comparer.GetHashCode(nul));
}
{
var op = new MonadAbstraction(type2, new LambdaAbstraction(Expression.Lambda(Expression.Constant(41), Expression.Parameter(type1)), new QueryTree[] { lambdaAbstraction1 }.ToReadOnly()));
var nul = new MonadAbstraction(type2, inner: null);
Assert.IsFalse(comparer.Equals(op, nul));
Assert.IsFalse(comparer.Equals(nul, op));
Assert.IsTrue(comparer.Equals(nul, nul));
}
}
}
public void QueryTree_Update()
{
var customType = typeof(int);
var customType2 = typeof(int);
var monadMember = (MonadMember) new MonadAbstraction(customType, inner: null);
var lambdaAbstraction = new LambdaAbstraction(body: null, parameters: null);
var updatedCustomType = typeof(int);
var updatedMonadMember = (MonadMember) new MonadAbstraction(updatedCustomType, inner: null);
var updatedLambdaAbstraction = new LambdaAbstraction(body: null, parameters: null);
{
var op = new FirstOperator(customType, monadMember);
var unchanged = op.Update(monadMember);
Assert.AreSame(op, unchanged);
var op2 = op.Update(updatedMonadMember);
Assert.AreNotSame(op, op2);
Assert.AreSame(updatedMonadMember, op2.Source);
}
{
var op = new FirstPredicateOperator(customType, monadMember, lambdaAbstraction);
var unchanged = op.Update(monadMember, lambdaAbstraction);
Assert.AreSame(op, unchanged);
var op2 = op.Update(updatedMonadMember, lambdaAbstraction);
Assert.AreNotSame(op, op2);
Assert.AreSame(updatedMonadMember, op2.Source);
Assert.AreSame(lambdaAbstraction, op2.Predicate);
var op3 = op.Update(monadMember, updatedLambdaAbstraction);
Assert.AreNotSame(op, op3);
Assert.AreSame(monadMember, op3.Source);
Assert.AreSame(updatedLambdaAbstraction, op3.Predicate);
}
{
var op = new SelectOperator(customType, customType2, monadMember, lambdaAbstraction);
var unchanged = op.Update(monadMember, lambdaAbstraction);
Assert.AreSame(op, unchanged);
var op2 = op.Update(updatedMonadMember, lambdaAbstraction);
Assert.AreNotSame(op, op2);
Assert.AreSame(updatedMonadMember, op2.Source);
Assert.AreSame(lambdaAbstraction, op2.Selector);
var op3 = op.Update(monadMember, updatedLambdaAbstraction);
Assert.AreNotSame(op, op3);
Assert.AreSame(monadMember, op3.Source);
Assert.AreSame(updatedLambdaAbstraction, op3.Selector);
}
{
var op = new TakeOperator(customType, monadMember, lambdaAbstraction);
var unchanged = op.Update(monadMember, lambdaAbstraction);
Assert.AreSame(op, unchanged);
var op2 = op.Update(updatedMonadMember, lambdaAbstraction);
Assert.AreNotSame(op, op2);
Assert.AreSame(updatedMonadMember, op2.Source);
Assert.AreSame(lambdaAbstraction, op2.Count);
var op3 = op.Update(monadMember, updatedLambdaAbstraction);
Assert.AreNotSame(op, op3);
Assert.AreSame(monadMember, op3.Source);
Assert.AreSame(updatedLambdaAbstraction, op3.Count);
}
{
var op = new WhereOperator(customType, monadMember, lambdaAbstraction);
var unchanged = op.Update(monadMember, lambdaAbstraction);
Assert.AreSame(op, unchanged);
var op2 = op.Update(updatedMonadMember, lambdaAbstraction);
Assert.AreNotSame(op, op2);
Assert.AreSame(updatedMonadMember, op2.Source);
Assert.AreSame(lambdaAbstraction, op2.Predicate);
var op3 = op.Update(monadMember, updatedLambdaAbstraction);
Assert.AreNotSame(op, op3);
Assert.AreSame(monadMember, op3.Source);
Assert.AreSame(updatedLambdaAbstraction, op3.Predicate);
}
{
var ma = new MonadAbstraction(customType, lambdaAbstraction);
var unchanged = ma.Update(lambdaAbstraction);
Assert.AreSame(ma, unchanged);
var ma2 = ma.Update(updatedLambdaAbstraction);
Assert.AreNotSame(ma, ma2);
Assert.AreSame(updatedLambdaAbstraction, ma2.Inner);
}
{
var lambda = Expression.Lambda(Expression.Empty(), Expression.Parameter(typeof(int)));
var parameters = new QueryTree[] { monadMember }.ToReadOnly();
var updatedLambda = Expression.Lambda(Expression.Empty(), Expression.Parameter(typeof(int)));
var updatedParameters = new QueryTree[] { monadMember }.ToReadOnly();
var la = new LambdaAbstraction(lambda, parameters);
var unchanged = la.Update(lambda, parameters);
Assert.AreSame(la, unchanged);
var la2 = la.Update(updatedLambda, parameters);
Assert.AreNotSame(la, la2);
Assert.AreSame(updatedLambda, la2.Body);
CollectionAssert.AreEqual(parameters, la2.Parameters); // A ToReadOnly is called on the IE<QT>
var la3 = la.Update(lambda, updatedParameters);
Assert.AreNotSame(la, la3);
Assert.AreSame(lambda, la3.Body);
CollectionAssert.AreEqual(updatedParameters, la3.Parameters);
}
}
public void QueryTree_Simple()
{
var customType = typeof(int);
var customType2 = typeof(int);
var monadMember = (MonadMember) new MonadAbstraction(customType, inner: null);
var lambdaAbstraction = new LambdaAbstraction(body: null, parameters: null);
{
var op = new FirstOperator(customType, monadMember);
Assert.AreEqual(QueryNodeType.Operator, op.QueryNodeType);
Assert.AreEqual(OperatorType.First, op.NodeType);
Assert.AreSame(customType, op.ElementType);
Assert.AreSame(monadMember, op.Source);
}
{
var op = new FirstPredicateOperator(customType, monadMember, lambdaAbstraction);
Assert.AreEqual(QueryNodeType.Operator, op.QueryNodeType);
Assert.AreEqual(OperatorType.FirstPredicate, op.NodeType);
Assert.AreSame(customType, op.ElementType);
Assert.AreSame(monadMember, op.Source);
Assert.AreSame(lambdaAbstraction, op.Predicate);
}
{
var op = new SelectOperator(customType, customType2, monadMember, lambdaAbstraction);
Assert.AreEqual(QueryNodeType.Operator, op.QueryNodeType);
Assert.AreEqual(OperatorType.Select, op.NodeType);
Assert.AreSame(customType, op.ElementType);
Assert.AreSame(customType2, op.InputElementType);
Assert.AreSame(monadMember, op.Source);
Assert.AreSame(lambdaAbstraction, op.Selector);
}
{
var op = new TakeOperator(customType, monadMember, lambdaAbstraction);
Assert.AreEqual(QueryNodeType.Operator, op.QueryNodeType);
Assert.AreEqual(OperatorType.Take, op.NodeType);
Assert.AreSame(customType, op.ElementType);
Assert.AreSame(monadMember, op.Source);
Assert.AreSame(lambdaAbstraction, op.Count);
}
{
var op = new WhereOperator(customType, monadMember, lambdaAbstraction);
Assert.AreEqual(QueryNodeType.Operator, op.QueryNodeType);
Assert.AreEqual(OperatorType.Where, op.NodeType);
Assert.AreSame(customType, op.ElementType);
Assert.AreSame(monadMember, op.Source);
Assert.AreSame(lambdaAbstraction, op.Predicate);
}
{
var op = new MonadAbstraction(customType, lambdaAbstraction);
Assert.AreEqual(QueryNodeType.MonadAbstraction, op.QueryNodeType);
Assert.AreSame(customType, op.ElementType);
Assert.AreSame(lambdaAbstraction, op.Inner);
}
{
var lambda = Expression.Lambda <Action>(Expression.Empty());
var parameters = new QueryTree[] { monadMember }.ToReadOnly();
var op = new LambdaAbstraction(lambda, parameters);
Assert.AreEqual(QueryNodeType.Lambda, op.QueryNodeType);
Assert.AreSame(lambda, op.Body);
Assert.AreSame(parameters, op.Parameters);
}
}
public void QueryVisitor_Simple()
{
var type = typeof(ArgumentException);
var type2 = typeof(Exception);
var lambdaAbstraction1 = DefaultQueryExpressionFactory.Instance.LambdaAbstraction(Expression.Lambda(Expression.Empty()));
var lambdaAbstraction2 = DefaultQueryExpressionFactory.Instance.LambdaAbstraction(Expression.Lambda(Expression.Empty()));
var monadMember1 = DefaultQueryExpressionFactory.Instance.MonadAbstraction(type, lambdaAbstraction1);
var monadMember2 = DefaultQueryExpressionFactory.Instance.MonadAbstraction(type, lambdaAbstraction2);
var cmp = new QueryExpressionEqualityComparer();
{
var op = new FirstOperator(type, monadMember1);
var rewritten = new ReferenceEqualSubstitutionVisitor(monadMember1, monadMember2).Visit(op);
Assert.AreNotSame(op, rewritten);
Assert.IsTrue(cmp.Equals(op, rewritten));
}
{
var op = new FirstPredicateOperator(type, monadMember1, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualSubstitutionVisitor(monadMember1, monadMember2).Visit(op);
Assert.AreNotSame(op, rewritten1);
Assert.IsTrue(cmp.Equals(op, rewritten1));
var rewritten2 = new ReferenceEqualSubstitutionVisitor(lambdaAbstraction1, lambdaAbstraction2).Visit(op);
Assert.AreNotSame(op, rewritten2);
Assert.IsTrue(cmp.Equals(op, rewritten2));
}
{
var op = new SelectOperator(type, type2, monadMember1, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualSubstitutionVisitor(monadMember1, monadMember2).Visit(op);
Assert.AreNotSame(op, rewritten1);
Assert.IsTrue(cmp.Equals(op, rewritten1));
var rewritten2 = new ReferenceEqualSubstitutionVisitor(lambdaAbstraction1, lambdaAbstraction2).Visit(op);
Assert.AreNotSame(op, rewritten2);
Assert.IsTrue(cmp.Equals(op, rewritten2));
}
{
var op = new TakeOperator(type, monadMember1, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualSubstitutionVisitor(monadMember1, monadMember2).Visit(op);
Assert.AreNotSame(op, rewritten1);
Assert.IsTrue(cmp.Equals(op, rewritten1));
var rewritten2 = new ReferenceEqualSubstitutionVisitor(lambdaAbstraction1, lambdaAbstraction2).Visit(op);
Assert.AreNotSame(op, rewritten2);
Assert.IsTrue(cmp.Equals(op, rewritten2));
}
{
var op = new WhereOperator(type, monadMember1, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualSubstitutionVisitor(monadMember1, monadMember2).Visit(op);
Assert.AreNotSame(op, rewritten1);
Assert.IsTrue(cmp.Equals(op, rewritten1));
var rewritten2 = new ReferenceEqualSubstitutionVisitor(lambdaAbstraction1, lambdaAbstraction2).Visit(op);
Assert.AreNotSame(op, rewritten2);
Assert.IsTrue(cmp.Equals(op, rewritten2));
}
{
var op = new MonadAbstraction(type, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualSubstitutionVisitor(lambdaAbstraction1, lambdaAbstraction2).Visit(op);
Assert.AreNotSame(op, rewritten1);
Assert.IsTrue(cmp.Equals(op, rewritten1));
}
{
var lambda = Expression.Lambda(Expression.Empty(), Expression.Parameter(type));
var parameters = new QueryTree[] { monadMember1 }.ToReadOnly();
var op = new LambdaAbstraction(lambda, parameters);
var rewritten1 = new ReferenceEqualSubstitutionVisitor(monadMember1, monadMember2).Visit(op);
Assert.AreNotSame(op, rewritten1);
Assert.IsTrue(cmp.Equals(op, rewritten1));
}
}
public void QueryVisitor_Reflection_Identity()
{
var type = typeof(int);
var type2 = typeof(bool);
var type3 = typeof(object);
var lambdaAbstraction1 = DefaultQueryExpressionFactory.Instance.LambdaAbstraction(Expression.Lambda(Expression.Empty()));
var monadMember1 = DefaultQueryExpressionFactory.Instance.MonadAbstraction(type, lambdaAbstraction1);
var cmp = new QueryExpressionEqualityComparer();
{
var op = new FirstOperator(type, monadMember1);
var rewritten1 = new ReferenceEqualTypeSubstitutionVisitor(type, type).Visit(op);
Assert.AreSame(op, rewritten1);
var rewritten2 = new ReferenceEqualTypeSubstitutionVisitor(type, type2).Visit(op);
Assert.IsFalse(cmp.Equals(op, rewritten2));
var rewritten3 = new ReferenceEqualTypeSubstitutionVisitor(type2, type).Visit(op);
Assert.IsTrue(cmp.Equals(op, rewritten3));
}
{
var op = new FirstPredicateOperator(type, monadMember1, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualTypeSubstitutionVisitor(type, type).Visit(op);
Assert.AreSame(op, rewritten1);
var rewritten2 = new ReferenceEqualTypeSubstitutionVisitor(type, type2).Visit(op);
Assert.IsFalse(cmp.Equals(op, rewritten2));
var rewritten3 = new ReferenceEqualTypeSubstitutionVisitor(type2, type).Visit(op);
Assert.IsTrue(cmp.Equals(op, rewritten3));
}
{
var op = new SelectOperator(type, type3, monadMember1, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualTypeSubstitutionVisitor(type, type).Visit(op);
Assert.AreSame(op, rewritten1);
var rewritten2 = new ReferenceEqualTypeSubstitutionVisitor(type, type2).Visit(op);
Assert.IsFalse(cmp.Equals(op, rewritten2));
var rewritten3 = new ReferenceEqualTypeSubstitutionVisitor(type2, type).Visit(op);
Assert.IsTrue(cmp.Equals(op, rewritten3));
}
{
var op = new TakeOperator(type, monadMember1, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualTypeSubstitutionVisitor(type, type).Visit(op);
Assert.AreSame(op, rewritten1);
var rewritten2 = new ReferenceEqualTypeSubstitutionVisitor(type, type2).Visit(op);
Assert.IsFalse(cmp.Equals(op, rewritten2));
var rewritten3 = new ReferenceEqualTypeSubstitutionVisitor(type2, type).Visit(op);
Assert.IsTrue(cmp.Equals(op, rewritten3));
}
{
var op = new WhereOperator(type, monadMember1, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualTypeSubstitutionVisitor(type, type).Visit(op);
Assert.AreSame(op, rewritten1);
var rewritten2 = new ReferenceEqualTypeSubstitutionVisitor(type, type2).Visit(op);
Assert.IsFalse(cmp.Equals(op, rewritten2));
var rewritten3 = new ReferenceEqualTypeSubstitutionVisitor(type2, type).Visit(op);
Assert.IsTrue(cmp.Equals(op, rewritten3));
}
{
var op = new MonadAbstraction(type, lambdaAbstraction1);
var rewritten1 = new ReferenceEqualTypeSubstitutionVisitor(type, type).Visit(op);
Assert.AreSame(op, rewritten1);
var rewritten2 = new ReferenceEqualTypeSubstitutionVisitor(type, type2).Visit(op);
Assert.IsFalse(cmp.Equals(op, rewritten2));
var rewritten3 = new ReferenceEqualTypeSubstitutionVisitor(type2, type).Visit(op);
Assert.IsTrue(cmp.Equals(op, rewritten3));
}
}
public override T VisitTakeOperator(TakeOperator node)
{
throw new NotImplementedException();
}
