Esempio n. 1
0
        public void Equals()
        {
            UntilExpression cmd1 = new UntilExpression(new ConstantExpression(1), new AssignExpression("one", new ConstantExpression(1)));
            UntilExpression cmd2 = new UntilExpression(new ConstantExpression(2), new AssignExpression("one", new ConstantExpression(1)));
            UntilExpression cmd3 = new UntilExpression(new ConstantExpression(1), new AssignExpression("one", new ConstantExpression(2)));
            UntilExpression cmd4 = new UntilExpression(new ConstantExpression(1), new AssignExpression("one", new ConstantExpression(1)));

            Assert.IsTrue(cmd1.Equals(cmd4));
            Assert.IsTrue(cmd4.Equals(cmd1));
            Assert.AreEqual(cmd1.GetHashCode(), cmd4.GetHashCode());

            Assert.IsFalse(cmd1.Equals(null));
            Assert.IsFalse(cmd1.Equals(123));
            Assert.IsFalse(cmd1.Equals(cmd2));
            Assert.IsFalse(cmd1.Equals(cmd3));
        }
Esempio n. 2
0
        public void ParseUntilCommandWithDo()
        {
            Parser      cmdparser  = new Parser("a = a + 1");
            IExpression body       = cmdparser.ParseCommand();
            Parser      exprparser = new Parser("a >= 6");
            IExpression expr       = exprparser.ParseExpression();

            Parser      parser   = new Parser("until a>=6 do a=a+1; end");
            IExpression expected = new UntilExpression(expr, body);

            var result = parser.ParseCommand();

            Assert.IsNotNull(result);
            Assert.AreEqual(expected, result);

            Assert.IsNull(parser.ParseCommand());
        }
Esempio n. 3
0
        public void ExecuteSimpleUntilWhenConditionIsTrue()
        {
            Parser      cmdparser  = new Parser("a = a + 1");
            IExpression body       = cmdparser.ParseCommand();
            Parser      exprparser = new Parser("a >= 6");
            IExpression expr       = exprparser.ParseExpression();

            Context context = new Context();

            context.SetLocalValue("a", 1);

            UntilExpression cmd = new UntilExpression(expr, body);

            Assert.IsNull(cmd.Evaluate(context));

            Assert.AreEqual(6, context.GetValue("a"));
        }
 protected virtual Expression VisitUntil(UntilExpression node)
 {
     Visit(node.Test);
     Visit(node.Body);
     return(node);
 }