protected internal override QueryOperator VisitFirstPredicate(FirstPredicateOperator op) { var o = (FirstPredicateOperator)base.VisitFirstPredicate(op); var m = op.QueryExpressionFactory.First(o.ElementType, o.Source, o.Predicate); 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(FirstPredicateOperator obj) { return(GetHashCodeFirstPredicate(obj)); }
public bool Equals(FirstPredicateOperator x, FirstPredicateOperator y) { return(EqualsFirstPredicate(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)); } }