C# (CSharp) UnitTest.Template LexicalParser.Parse Examples

Example #1

File: NodeTest.cs Project: rexzh/RexToy

 public void TestForNodeWithColon()
 {
     string t = "#{:for i in array[1 : 10]:}";
     LexicalParser lp = new LexicalParser();
     lp.SetParseContent(t);
     var tokens = lp.Parse();
     ForNode f = new ForNode(tokens[0]);
 }

Example #2

File: NodeTest.cs Project: rexzh/RexToy

 public void TestForNodeLackInKeyword()
 {
     string t = "#{for i array[1, 2, 3]}";
     LexicalParser lp = new LexicalParser();
     lp.SetParseContent(t);
     var tokens = lp.Parse();
     ForNode f = new ForNode(tokens[0]);
 }

Example #3

File: NodeTest.cs Project: rexzh/RexToy

 public void TestIfNodeNoExpr()
 {
     string t = "#{if }#{end}";
     LexicalParser lp = new LexicalParser();
     lp.SetParseContent(t);
     var tokens = lp.Parse();
     IfNode i = new IfNode(tokens[0]);
 }

Example #4

File: LexicalParseTest.cs Project: rexzh/RexToy

 public void TestEscape()
 {
     LexicalParser p = new LexicalParser();
     p.SetParseContent("##{content}");
     var l = p.Parse();
     Assert.AreEqual(TokenType.Text, l[0].TokenType);
     Assert.AreEqual(1, l.Count);
 }

Example #5

File: LexicalParseTest.cs Project: rexzh/RexToy

 public void TestEndColon()
 {
     LexicalParser p = new LexicalParser();
     p.SetParseContent("#{//Comment Line.:}");
     var l = p.Parse();
     Assert.AreEqual(TokenType.Remark, l[0].TokenType);
     Assert.AreEqual(1, l.Count);
 }

Example #6

File: NodeTest.cs Project: rexzh/RexToy

 public void TestForNodeInvalidVarName()
 {
     string t = "#{for $ in array[1, 2, 3]}";
     LexicalParser lp = new LexicalParser();
     lp.SetParseContent(t);
     var tokens = lp.Parse();
     ForNode f = new ForNode(tokens[0]);
 }

Example #7

File: LexicalParseTest.cs Project: rexzh/RexToy

 public void TestBeginColon()
 {
     LexicalParser p = new LexicalParser();
     p.SetParseContent("#{:include \"head.tpl\"}");
     var l = p.Parse();
     Assert.AreEqual(TokenType.Include, l[0].TokenType);
     Assert.AreEqual(1, l.Count);
 }

Example #8

        public void TestLetNodeNoExpr()
        {
            string        t  = "#{let c=   }";
            LexicalParser lp = new LexicalParser();

            lp.SetParseContent(t);
            var     tokens = lp.Parse();
            LetNode l      = new LetNode(tokens[0]);
        }

Example #9

        public void TestForNodeInvalidVarName()
        {
            string        t  = "#{for $ in array[1, 2, 3]}";
            LexicalParser lp = new LexicalParser();

            lp.SetParseContent(t);
            var     tokens = lp.Parse();
            ForNode f      = new ForNode(tokens[0]);
        }

Example #10

        public void TestForNodeLackInKeyword()
        {
            string        t  = "#{for i array[1, 2, 3]}";
            LexicalParser lp = new LexicalParser();

            lp.SetParseContent(t);
            var     tokens = lp.Parse();
            ForNode f      = new ForNode(tokens[0]);
        }

Example #11

        public void TestIfNodeNoExpr()
        {
            string        t  = "#{if }#{end}";
            LexicalParser lp = new LexicalParser();

            lp.SetParseContent(t);
            var    tokens = lp.Parse();
            IfNode i      = new IfNode(tokens[0]);
        }

Example #12

File: NodeTest.cs Project: rexzh/RexToy

 public void TestIfNode()
 {
     string t = "#{if a}#{end}";
     LexicalParser lp = new LexicalParser();
     lp.SetParseContent(t);
     var tokens = lp.Parse();
     IfNode i = new IfNode(tokens[0]);
     Assert.AreEqual("a", i.Expr);
 }

Example #13

        public void TestLetNodeNoEqualOperator()
        {
            string        t  = "#{let c   tuple[x:3, y:5]}";
            LexicalParser lp = new LexicalParser();

            lp.SetParseContent(t);
            var     tokens = lp.Parse();
            LetNode l      = new LetNode(tokens[0]);
        }

Example #14

        public void TestForNodeWithColon()
        {
            string        t  = "#{:for i in array[1 : 10]:}";
            LexicalParser lp = new LexicalParser();

            lp.SetParseContent(t);
            var     tokens = lp.Parse();
            ForNode f      = new ForNode(tokens[0]);
        }

Example #15

File: LexicalParseTest.cs Project: rexzh/RexToy

 public void TestCombine()
 {
     LexicalParser p = new LexicalParser();
     p.SetParseContent("#{if c>0}positive#{end}");
     var l = p.Parse();
     Assert.AreEqual(TokenType.If, l[0].TokenType);
     Assert.AreEqual(TokenType.Text, l[1].TokenType);
     Assert.AreEqual(TokenType.End, l[2].TokenType);
     Assert.AreEqual(3, l.Count);
 }

Example #16

File: NodeTest.cs Project: rexzh/RexToy

 public void TestForNode()
 {
     string t = "#{ for i  in array[3  :8]}#{i }#{end}";
     LexicalParser lp = new LexicalParser();
     lp.SetParseContent(t);
     var tokens = lp.Parse();
     ForNode f = new ForNode(tokens[0]);
     Assert.AreEqual("i", f.Var);
     Assert.AreEqual("array[3  :8]", f.Enumerable);
 }

Example #17

File: LexicalParseTest.cs Project: rexzh/RexToy

        public void TestBeginColon()
        {
            LexicalParser p = new LexicalParser();

            p.SetParseContent("#{:include \"head.tpl\"}");
            var l = p.Parse();

            Assert.AreEqual(TokenType.Include, l[0].TokenType);
            Assert.AreEqual(1, l.Count);
        }

Example #18

File: LexicalParseTest.cs Project: rexzh/RexToy

        public void TestEscape()
        {
            LexicalParser p = new LexicalParser();

            p.SetParseContent("##{content}");
            var l = p.Parse();

            Assert.AreEqual(TokenType.Text, l[0].TokenType);
            Assert.AreEqual(1, l.Count);
        }

Example #19

File: LexicalParseTest.cs Project: rexzh/RexToy

        public void TestEndColon()
        {
            LexicalParser p = new LexicalParser();

            p.SetParseContent("#{//Comment Line.:}");
            var l = p.Parse();

            Assert.AreEqual(TokenType.Remark, l[0].TokenType);
            Assert.AreEqual(1, l.Count);
        }

Example #20

File: LexicalParseTest.cs Project: rexzh/RexToy

        public void TestSimple()
        {
            LexicalParser p = new LexicalParser();

            p.SetParseContent("#{let a=3}");
            var l = p.Parse();

            Assert.AreEqual(TokenType.Let, l[0].TokenType);
            Assert.AreEqual(1, l.Count);
        }

Example #21

File: LexicalParseTest.cs Project: rexzh/RexToy

        public void TestRemoveNextSpace()
        {
            LexicalParser p = new LexicalParser();
            p.SetParseContent("#{if i>5:}  \r\n\ti>5\r\n#{end}");
            var l = p.Parse();
            Assert.AreEqual(TokenType.Text, l[1].TokenType);
            Assert.AreEqual(3, l.Count);

            var text = l[1];
            Assert.AreEqual("\ti>5\r\n", text.TokenValue);
        }

Example #22

        public void TestIfNode()
        {
            string        t  = "#{if a}#{end}";
            LexicalParser lp = new LexicalParser();

            lp.SetParseContent(t);
            var    tokens = lp.Parse();
            IfNode i      = new IfNode(tokens[0]);

            Assert.AreEqual("a", i.Expr);
        }

Example #23

File: LexicalParseTest.cs Project: rexzh/RexToy

        public void TestCombine()
        {
            LexicalParser p = new LexicalParser();

            p.SetParseContent("#{if c>0}positive#{end}");
            var l = p.Parse();

            Assert.AreEqual(TokenType.If, l[0].TokenType);
            Assert.AreEqual(TokenType.Text, l[1].TokenType);
            Assert.AreEqual(TokenType.End, l[2].TokenType);
            Assert.AreEqual(3, l.Count);
        }

Example #24

        public void TestLetNode()
        {
            string        t  = "#{let c = tuple[x:3, y:5]}";
            LexicalParser lp = new LexicalParser();

            lp.SetParseContent(t);
            var     tokens = lp.Parse();
            LetNode l      = new LetNode(tokens[0]);

            Assert.AreEqual("c", l.VarName);
            Assert.AreEqual("tuple[x:3, y:5]", l.Expression);
        }

Example #25

        public void TestForNode()
        {
            string        t  = "#{ for i  in array[3  :8]}#{i }#{end}";
            LexicalParser lp = new LexicalParser();

            lp.SetParseContent(t);
            var     tokens = lp.Parse();
            ForNode f      = new ForNode(tokens[0]);

            Assert.AreEqual("i", f.Var);
            Assert.AreEqual("array[3  :8]", f.Enumerable);
        }

Example #26

File: LexicalParseTest.cs Project: rexzh/RexToy

        public void TestRemovePrevSpace()
        {
            LexicalParser p = new LexicalParser();

            p.SetParseContent("#{if i>5}  \r\n\ti>5\r\n#{:end}");
            var l = p.Parse();

            Assert.AreEqual(TokenType.Text, l[1].TokenType);
            Assert.AreEqual(3, l.Count);

            var text = l[1];

            Assert.AreEqual("  \r\n\ti>5", text.TokenValue);
        }

Example #27

File: LexicalParseTest.cs Project: rexzh/RexToy

 public void TestSimple()
 {
     LexicalParser p = new LexicalParser();
     p.SetParseContent("#{let a=3}");
     var l = p.Parse();
     Assert.AreEqual(TokenType.Let, l[0].TokenType);
     Assert.AreEqual(1, l.Count);
 }

Example #28

File: NodeTest.cs Project: rexzh/RexToy

 public void TestLetNodeNoExpr()
 {
     string t = "#{let c=   }";
     LexicalParser lp = new LexicalParser();
     lp.SetParseContent(t);
     var tokens = lp.Parse();
     LetNode l = new LetNode(tokens[0]);
 }

Example #29

File: NodeTest.cs Project: rexzh/RexToy

 public void TestLetNode()
 {
     string t = "#{let c = tuple[x:3, y:5]}";
     LexicalParser lp = new LexicalParser();
     lp.SetParseContent(t);
     var tokens = lp.Parse();
     LetNode l = new LetNode(tokens[0]);
     Assert.AreEqual("c", l.VarName);
     Assert.AreEqual("tuple[x:3, y:5]", l.Expression);
 }

Example #30

File: NodeTest.cs Project: rexzh/RexToy

 public void TestLetNodeNoEqualOperator()
 {
     string t = "#{let c   tuple[x:3, y:5]}";
     LexicalParser lp = new LexicalParser();
     lp.SetParseContent(t);
     var tokens = lp.Parse();
     LetNode l = new LetNode(tokens[0]);
 }