Esempio n. 1
0
        public void TestBiggerSubExpression()
        {
            string expr      = "(1+(15*(5-2)))";
            int    readIndex = 1;

            Assert.AreEqual("1+(15*(5-2))", SimpleExpressionParser.GetExpression(expr, ref readIndex));
        }
        public void placeholders_with_recursion()
        {
            IValueEvaluator[] evaluators =
            {
                new DictionaryEvaluator("eval1", new Dictionary <string, string> {
                    { "Prop1",                   "Value1" },                     { "Prop2","Value2" }, { "Success", "Success!" }
                }),
                new DictionaryEvaluator("eval2", new Dictionary <string, string> {
                    { "Value1_Value2",           "Success" }
                }),
            };

            SimpleExpressionParser
            .ParseAndRender("${eval1:Prop1}_${eval1:Prop2}", evaluators)
            .Should().Be("Value1_Value2");

            SimpleExpressionParser
            .ParseAndRender("${eval2:${eval1:Prop1}_${eval1:Prop2}}", evaluators)
            .Should().Be("Success");

            evaluators = evaluators.Reverse().ToArray();
            SimpleExpressionParser
            .ParseAndRender("${eval2:${eval1:Prop1}_${eval1:Prop2}}", evaluators)
            .Should().Be("Success");

            SimpleExpressionParser
            .ParseAndRender("${eval1:${eval2:${eval1:Prop1}_${eval1:Prop2}}}", evaluators)
            .Should().Be("Success!");
        }
Esempio n. 3
0
        public void TestSubExpressionInvalid()
        {
            string expr      = "((1+1)*7";
            int    readIndex = 1;

            Assert.ThrowsException <InvalidExpressionSyntaxException>(() => SimpleExpressionParser.GetExpression(expr, ref readIndex));
        }
Esempio n. 4
0
        public void TestSubExpressions()
        {
            string expr      = "(15+3)";
            int    readIndex = 1;

            Assert.AreEqual("15+3", SimpleExpressionParser.GetExpression(expr, ref readIndex));
        }
Esempio n. 5
0
        private static BuildResult <Parser <ExpressionToken, double> > BuildParserExpression()
        {
            var StartingRule   = $"{typeof(SimpleExpressionParser).Name}_expressions";
            var parserInstance = new SimpleExpressionParser();
            var builder        = new ParserBuilder <ExpressionToken, double>();

            return(builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, StartingRule));
        }
Esempio n. 6
0
        private void BuildParser()
        {
            StartingRule = $"{typeof(SimpleExpressionParser).Name}_expressions";
            var parserInstance = new SimpleExpressionParser();
            var builder        = new ParserBuilder <ExpressionToken, double>();

            Parser = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, StartingRule);
        }
Esempio n. 7
0
        public void CanParseSuffixes(string source, string result)
        {
            var parser = new SimpleExpressionParser();

            parser.Operators = new[] { '+' };
            parser.Suffixes  = new[] { '*' };
            Assert.AreEqual(result, parser.Parse(source).GetDescriptiveString());
        }
        private static void AssertParse(string input, Expression expectation)
        {
            var source   = input;
            var parser   = new SimpleExpressionParser();
            var expr     = parser.Parse(source);
            var expected = expectation;

            expr.ShouldDeepEqual(expected);
        }
        private static void AssertParse(string input, string expected)
        {
            var parser = new SimpleExpressionParser();
            var ast    = parser.Parse(input);

            var sut = new ExpressionFormatter();

            ast.Accept(sut);
            Assert.Equal(expected, sut.GetResult());
        }
        private static void AssertThrows <TEx>(string source) where TEx : Exception
        {
            var parser = new SimpleExpressionParser();

            Assert.Throws <TEx>(() =>
            {
                var expression = parser.Parse(source);
                return(expression);
            });
        }
Esempio n. 11
0
        private static Parser <ExpressionToken, double> BuildParser()
        {
            var StartingRule   = $"{typeof(SimpleExpressionParser).Name}_expressions";
            var parserInstance = new SimpleExpressionParser();
            var builder        = new ParserBuilder <ExpressionToken, double>();
            var pBuild         = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, StartingRule);

            Assert.True(pBuild.IsOk);
            Assert.NotNull(pBuild.Result);
            return(pBuild.Result);
        }
Esempio n. 12
0
        public void SyntaxTreeGraphVizTest()
        {
            var StartingRule   = $"{typeof(SimpleExpressionParser).Name}_expressions";
            var parserInstance = new SimpleExpressionParser();
            var builder        = new ParserBuilder <ExpressionToken, int>();
            var Parser         = builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, StartingRule);
            var result         = Parser.Result.Parse("1+1");

            var    tree     = result.SyntaxTree;
            var    graphviz = new GraphVizEBNFSyntaxTreeVisitor <ExpressionToken>();
            var    root     = graphviz.VisitTree(tree);
            string graph    = graphviz.Graph.Compile();
        }
Esempio n. 13
0
        private static void TestGraphViz()
        {
            var    StartingRule   = $"{typeof(SimpleExpressionParser).Name}_expressions";
            var    parserInstance = new SimpleExpressionParser();
            var    builder        = new ParserBuilder <ExpressionToken, int>();
            var    parser         = builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, StartingRule);
            var    result         = parser.Result.Parse("2 + 2 * 3");
            var    tree           = result.SyntaxTree;
            var    graphviz       = new GraphVizEBNFSyntaxTreeVisitor <ExpressionToken>();
            var    root           = graphviz.VisitTree(tree);
            string graph          = graphviz.Graph.Compile();

            File.Delete("c:\\temp\\tree.dot");
            File.AppendAllText("c:\\temp\\tree.dot", graph);
        }
        public void expression_with_error()
        {
            IValueEvaluator[] evaluators =
            {
                new DictionaryEvaluator("eval1", new Dictionary <string, string> {
                    { "Prop1",                   "Value1" },                     { "Prop2","Value2" }, { "Success", "Success!" }
                }),
                new DictionaryEvaluator("eval2", new Dictionary <string, string> {
                    { "Value1_Value2",           "Success" }
                }),
            };

            SimpleExpressionParser
            .ParseAndRender("${eval1:Prop1", evaluators)
            .Should().Be("${eval1:Prop1");
        }
Esempio n. 15
0
        public void TestCreateDot()
        {
            ANTLRStringStream input = new ANTLRStringStream( "3 * x" );
            SimpleExpressionLexer lexer = new SimpleExpressionLexer( input );
            CommonTokenStream tokens = new CommonTokenStream( lexer );
            SimpleExpressionParser parser = new SimpleExpressionParser( tokens );
            var result = parser.expression();

            var tree = result.Tree;
            var adaptor = parser.TreeAdaptor;

            DotTreeGenerator gen = new DotTreeGenerator();
            string output = gen.ToDot( tree, adaptor );
            string newline = Environment.NewLine;
            string expected =
                @"digraph {" + newline
                + newline
                + @"	ordering=out;" + newline
                + @"	ranksep=.4;" + newline
                + @"	bgcolor=""lightgrey""; node [shape=box, fixedsize=false, fontsize=12, fontname=""Helvetica-bold"", fontcolor=""blue""" + newline
                + @"		width=.25, height=.25, color=""black"", fillcolor=""white"", style=""filled, solid, bold""];" + newline
                + @"	edge [arrowsize=.5, color=""black"", style=""bold""]" + newline
                + newline
                + @"  n0 [label=""""];" + newline
                + @"  n1 [label=""*""];" + newline
                + @"  n1 [label=""*""];" + newline
                + @"  n2 [label=""3""];" + newline
                + @"  n3 [label=""x""];" + newline
                + @"  n4 [label=""""];" + newline
                + newline
                + @"  n0 -> n1 // """" -> ""*""" + newline
                + @"  n1 -> n2 // ""*"" -> ""3""" + newline
                + @"  n1 -> n3 // ""*"" -> ""x""" + newline
                + @"  n0 -> n4 // """" -> """"" + newline
                + newline
                + @"}" + newline
                + @"";

            Assert.AreEqual( expected, output );
        }
Esempio n. 16
0
        public void TestCreateDot()
        {
            ANTLRStringStream      input  = new ANTLRStringStream("3 * x");
            SimpleExpressionLexer  lexer  = new SimpleExpressionLexer(input);
            CommonTokenStream      tokens = new CommonTokenStream(lexer);
            SimpleExpressionParser parser = new SimpleExpressionParser(tokens);
            var result = parser.expression();

            var tree    = result.Tree;
            var adaptor = parser.TreeAdaptor;

            DotTreeGenerator gen      = new DotTreeGenerator();
            string           output   = gen.ToDot(tree, adaptor);
            string           newline  = Environment.NewLine;
            string           expected =
                @"digraph {" + newline
                + newline
                + @"	ordering=out;"+ newline
                + @"	ranksep=.4;"+ newline
                + @"	bgcolor=""lightgrey""; node [shape=box, fixedsize=false, fontsize=12, fontname=""Helvetica-bold"", fontcolor=""blue"""+ newline
                + @"		width=.25, height=.25, color=""black"", fillcolor=""white"", style=""filled, solid, bold""];"+ newline
                + @"	edge [arrowsize=.5, color=""black"", style=""bold""]"+ newline
                + newline
                + @"  n0 [label=""""];" + newline
                + @"  n1 [label=""*""];" + newline
                + @"  n1 [label=""*""];" + newline
                + @"  n2 [label=""3""];" + newline
                + @"  n3 [label=""x""];" + newline
                + @"  n4 [label=""""];" + newline
                + newline
                + @"  n0 -> n1 // """" -> ""*""" + newline
                + @"  n1 -> n2 // ""*"" -> ""3""" + newline
                + @"  n1 -> n3 // ""*"" -> ""x""" + newline
                + @"  n0 -> n4 // """" -> """"" + newline
                + newline
                + @"}" + newline
                + @"";

            Assert.AreEqual(expected, output);
        }
 public SimpleExpressionParserTest()
 {
     _parser = new SimpleExpressionParser();
 }
 public void CanParseSuffixes(string source, string result) {
     var parser = new SimpleExpressionParser();
     parser.Operators = new[] {'+'};
     parser.Suffixes = new[] {'*'};
     Assert.AreEqual(result, parser.Parse(source).GetDescriptiveString());
 }