C# (CSharp) UnitTest.Template LexicalParser.Parseの例

コード例 #1

ファイル: NodeTest.cs プロジェクト: 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]);
 }

コード例 #2

ファイル: NodeTest.cs プロジェクト: 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]);
 }

コード例 #3

ファイル: NodeTest.cs プロジェクト: 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]);
 }

コード例 #4

ファイル: LexicalParseTest.cs プロジェクト: 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);
 }

コード例 #5

ファイル: LexicalParseTest.cs プロジェクト: 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);
 }

コード例 #6

ファイル: NodeTest.cs プロジェクト: 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]);
 }

コード例 #7

ファイル: LexicalParseTest.cs プロジェクト: 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);
 }

コード例 #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]);
        }

コード例 #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]);
        }

コード例 #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]);
        }

コード例 #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]);
        }

コード例 #12

ファイル: NodeTest.cs プロジェクト: 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);
 }

コード例 #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]);
        }

コード例 #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]);
        }

コード例 #15

ファイル: LexicalParseTest.cs プロジェクト: 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);
 }

コード例 #16

ファイル: NodeTest.cs プロジェクト: 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);
 }

コード例 #17

ファイル: LexicalParseTest.cs プロジェクト: 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);
        }

コード例 #18

ファイル: LexicalParseTest.cs プロジェクト: 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);
        }

コード例 #19

ファイル: LexicalParseTest.cs プロジェクト: 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);
        }

コード例 #20

ファイル: LexicalParseTest.cs プロジェクト: 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);
        }

コード例 #21

ファイル: LexicalParseTest.cs プロジェクト: 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);
        }

コード例 #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);
        }

コード例 #23

ファイル: LexicalParseTest.cs プロジェクト: 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);
        }

コード例 #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);
        }

コード例 #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);
        }

コード例 #26

ファイル: LexicalParseTest.cs プロジェクト: 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);
        }

コード例 #27

ファイル: LexicalParseTest.cs プロジェクト: 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);
 }

コード例 #28

ファイル: NodeTest.cs プロジェクト: 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]);
 }

コード例 #29

ファイル: NodeTest.cs プロジェクト: 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);
 }

コード例 #30

ファイル: NodeTest.cs プロジェクト: 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]);
 }