protected internal override QueryOperator VisitSelect(SelectOperator op) { var o = (SelectOperator)base.VisitSelect(op); var m = op.QueryExpressionFactory.Select(o.ElementType, o.InputElementType, o.Source, o.Selector); 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(SelectOperator obj) { return(GetHashCodeSelect(obj)); }
public bool Equals(SelectOperator x, SelectOperator y) { return(EqualsSelect(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 static ClientBasePacket HandlePacket(byte[] data, int offset, GameSession client) { // Calculate message size var size = (short)((data[offset + 1] << 8) + data[offset]); // Copy the packet to a new byte array // Skipping the header var packet = new byte[size]; Array.Copy(data, offset, packet, 0, size); ClientBasePacket msg; // Get the id var id = packet[2]; // Handle the packet // TODO: Can we group these into login / game / etc? switch (id) { case 0x00: msg = new ProtocolVersion(packet, client); break; case 0x01: msg = new ValidateClient(packet, client); break; case 0x03: msg = new ConnectClient(packet, client); break; case 0x04: msg = new ConnectSwitch(packet, client); break; case 0x05: msg = new SwitchServer(packet, client); break; case 0x06: msg = new ServerTime(packet, client); break; case 0x07: msg = new Message(packet, client); break; case 0x0d: msg = new Log(packet, client); break; case 0x0c: msg = new SyncMoney(packet, client); break; case 0x11: msg = new FactoryModifyUnit(packet, client); break; case 0x12: msg = new FactoryModifyEnd(packet, client); break; case 0x16: msg = new IsValidName(packet, client); break; case 0x17: msg = new FactoryChangeUnitName(packet, client); break; case 0x18: msg = new RequestInventory(packet, client); break; case 0x19: msg = new RequestSearchGame(packet, client); break; case 0x1b: msg = new CreateGame(packet, client); break; case 0x1c: msg = new EnterGame(packet, client); break; case 0x1f: msg = new ListUser(packet, client); break; case 0x20: msg = new Ready(packet, client); break; case 0x21: msg = new Exit(packet, client); break; case 0x22: msg = new StartGame(packet, client); break; case 0x2b: msg = new SelectBase(packet, client); break; case 0x2c: msg = new ReadyGame(packet, client); break; case 0x2e: msg = new RequestPalette(packet, client); break; case 0x2f: msg = new MoveUnit(packet, client); break; case 0x30: msg = new AimUnit(packet, client); break; case 0x31: msg = new StartAttack(packet, client); break; case 0x32: msg = new StopAttack(packet, client); break; case 0x35: msg = new RequestRegain(packet, client); break; case 0x38: msg = new ModeSniper(packet, client); break; case 0x3a: msg = new RequestChangeWeaponset(packet, client); break; case 0x3b: msg = new RequestQuitBattle(packet, client); break; case 0x3f: msg = new BuyList(packet, client); break; case 0x40: msg = new RequestGoodsData(packet, client); break; case 0x46: msg = new RequestAvatarInfo(packet, client); break; case 0x47: case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: msg = new RequestStatsInfo(packet, client); break; case 0x4e: msg = new RequestBestInfo(packet, client); break; case 0x57: msg = new TutorialSelect(packet, client); break; case 0x5a: msg = new UnAimUnit(packet, client); break; case 0x63: msg = new MsgConnect(packet, client); break; case 0x64: msg = new MsgUserStateInfo(packet, client); break; case 0x66: msg = new MsgUserClanInfo(packet, client); break; case 0x67: msg = new MsgGetBuddyList(packet, client); break; case 0x69: msg = new MsgGetChannelList(packet, client); break; case 0x6a: msg = new MsgJoinChannel(packet, client); break; case 0x6b: msg = new MsgLeaveChannel(packet, client); break; case 0x6c: msg = new MsgChannelChatting(packet, client); break; case 0x71: msg = new RequestOperator(packet, client); break; case 0x72: msg = new SelectOperator(packet, client); break; default: msg = new UnknownPacket(packet, client); //Console.WriteLine("Unknown packet id [{0}] from user {1}", id, client.GetUserName()); break; } return(msg); }
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)); } }