public void Evaluate_Test(string input, double output)
        {
            var lex = new RegexLexer();

            SuperBasicMathAst.AddMathTokens(lex);
            var tokens = lex.Tokenize(input);
            var t      = tree.Evaluate(tokens);

            t.Should().Be(output);
        }
Beispiel #2
0
        public void AddAndSubtract_Should_HaveSubAtTopOfTree()
        {
            var input = "1+2-3";

            var lex = new RegexLexer();

            SuperBasicMathAst.AddMathTokens(lex);
            var tree = new SuperBasicMathAst(lex.Tokenize(input));

            var t = tree.Evaluate().Should().BeOfType <BinaryOperator>().Which;

            t.Name.Should().Be(PascalTerms.Sub);
        }
Beispiel #3
0
        public void UnaryOperation()
        {
            var input = "-2";

            var lex = new RegexLexer();

            SuperBasicMathAst.AddMathTokens(lex);
            var tree = new SuperBasicMathAst(lex.Tokenize(input));

            var node = tree.Evaluate();

            node.Should().BeOfType <UnaryOperator>().Which.Name.Should().Be(PascalTerms.Sub);
        }
Beispiel #4
0
        public void Evaluate_Test(string input, double output)
        {
            var lex = new RegexLexer();

            SuperBasicMathAst.AddMathTokens(lex);
            var tree = new SuperBasicMathAst(lex.Tokenize(input));
            var t    = tree.Evaluate();

            var inter = new PascalInterpreter();

            var r = inter.VisitNode(t);

            r.Should().Be(output);
        }
Beispiel #5
0
        public void LispTest(string input, string output)
        {
            var lex = new RegexLexer();

            SuperBasicMathAst.AddMathTokens(lex);
            var tree = new SuperBasicMathAst(lex.Tokenize(input));

            var t = tree.Evaluate();

            var inter = new SuperBasicMathLispInterpreter();

            var result = inter.Evaluate(t);

            result.Should().Be(output);
        }
Beispiel #6
0
        public void RpnTest()
        {
            var input = "(5 + 3) * 12 / 3";
            var lex   = new RegexLexer();

            SuperBasicMathAst.AddMathTokens(lex);
            var tree = new SuperBasicMathAst(lex.Tokenize(input));

            var t = tree.Evaluate();

            var inter = new SuperBasicRpnMathInterpreter();

            var result = inter.Evaluate(t);

            result.Should().Be("5 3 + 12 * 3 /");
        }
Beispiel #7
0
        public void BasicAst_Should_Subtract()
        {
            var input = "1-2";
            var lex   = new RegexLexer();

            SuperBasicMathAst.AddMathTokens(lex);
            var tree = new SuperBasicMathAst(lex.Tokenize(input));
            var t    = tree.Evaluate().Should().BeOfType <BinaryOperator>().Which;

            t.TokenItem.Token.Name.Should().Be(PascalTerms.Sub);

            var left  = t.Left.Should().BeOfType <IntegerNode>().Which;
            var right = t.Right.Should().BeOfType <IntegerNode>().Which;

            left.TokenItem.Token.Name.Should().Be(PascalTerms.IntegerConst);
            left.TokenItem.Value.Should().Be("1");
            right.TokenItem.Token.Name.Should().Be(PascalTerms.IntegerConst);
            right.TokenItem.Value.Should().Be("2");
        }