Beispiel #1
0
        public void PatternSearch5_Skip()
        {
            var src = @"{a: 'Budilnik', 'Name': 'Znatoki', q:2, z: 148, 'hero': 0x7f}";

            var lxr = new JL(new StringSource(src));


            var capture = lxr.LazyFSM(
                (s, t) => s.Skip(1),
                (s, t) => FSMI.Take
                );

            Assert.IsNotNull(capture);
            Assert.AreEqual(JSONTokenType.tIdentifier, capture.Type);
            Assert.AreEqual("a", capture.Text);

            capture = lxr.LazyFSM(
                (s, t) => s.Skip(9),
                (s, t) => FSMI.Take
                );

            Assert.IsNotNull(capture);
            Assert.AreEqual(JSONTokenType.tIdentifier, capture.Type);
            Assert.AreEqual("q", capture.Text);
        }
Beispiel #2
0
        public void PatternSearch4_LoopUntilMatch()
        {
            var src = @"{a: 'Budilnik', 'Name': 'Znatoki', q: 2, z: 148, 'hero': 0x7f}";

            var lxr = new JL(new StringSource(src));


            var capture = lxr.LazyFSM(
                (s, t) => s.LoopUntilMatch(
                    (ss, tk) => tk.LoopUntilAny(JSONTokenType.tStringLiteral),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tColon),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tStringLiteral),
                    (ss, tk) => FSMI.TakeAndComplete
                    ),
                (s, t) => s.Skip(3),
                (s, t) => t.LoopUntilAny(JSONTokenType.tStringLiteral),
                (s, t) => t.IsAnyOrAbort(JSONTokenType.tColon),
                (s, t) => FSMI.Take,
                (s, t) => t.IsAnyOrAbort(JSONTokenType.tBraceClose)
                );

            Assert.IsNotNull(capture);

            Assert.AreEqual(JSONTokenType.tIntLiteral, capture.Type);
            Assert.AreEqual(127, capture.Value);
        }
Beispiel #3
0
 public override bool Match(NFX.CodeAnalysis.JSON.JSONLexer content)
 {
     return(content.LazyFSM(
                (s, t) => s.LoopUntilMatch(
                    (ss, tk) => tk.LoopUntilAny("First-Name", "FirstName", "first_name"),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tColon),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tStringLiteral),
                    (ss, tk) => FSMI.TakeAndComplete
                    ),
                (s, t) => FSMI.Take
                ) != null);
 }
Beispiel #4
0
        public void PatternSearch()
        {
            var src = @"{a: 2, b: 'Znatoki', c: false, d: null, e: ['a','b','c']}";

            var lxr = new JL(new StringSource(src));


            var bvalue = lxr.LazyFSM(
                (s, t) => t.LoopUntilAny("b"),
                (s, t) => t.IsAnyOrAbort(JSONTokenType.tColon),
                (s, t) => FSMI.TakeAndComplete
                );

            Assert.AreEqual("Znatoki", bvalue.Text);
        }
Beispiel #5
0
        public void PatternSearch3()
        {
            var src = @"{a: 2, b: 'Znatoki'}";

            var lxr = new JL(new StringSource(src));


            var bvalue = lxr.LazyFSM(
                (s, t) => t.LoopUntilAny("b"),
                (s, t) => t.IsAnyOrAbort(JSONTokenType.tColon),
                (s, t) => FSMI.Take,
                (s, t) => t.IsAnyOrAbort(JSONTokenType.tComma)
                );

            Assert.AreEqual(null, bvalue);
        }
Beispiel #6
0
        public void PatternSearch2()
        {
            var src = @"{a: 2, b: 'Znatoki', c: false}";

            var lxr = new JL(new StringSource(src));


            var bvalue = lxr.LazyFSM(
                (s, t) => t.LoopUntilAny("b"),
                (s, t) => t.IsAnyOrAbort(JSONTokenType.tColon),
                (s, t) => FSMI.Take,
                (s, t) => t.IsAnyOrAbort(JSONTokenType.tComma)
                );

            Aver.AreEqual("Znatoki", bvalue.Text);
        }
Beispiel #7
0
        public void PatternSearch10_LoopUntilAfterMatch()
        {
            var src = @"1,2,3,4,5,6,7,8,9 : 'Name': 'Znatoki' null 'ok'";

            var lxr = new JL(new StringSource(src));


            var capture = lxr.LazyFSM(
                (s, t) => s.LoopUntilAfterMatch(
                    (ss, tk) => tk.LoopUntilAny(JSONTokenType.tStringLiteral),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tColon),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tStringLiteral),
                    (ss, tk) => FSMI.TakeAndComplete
                    ),
                (s, t) => FSMI.Take
                );

            Assert.IsNotNull(capture);
            Assert.AreEqual(JSONTokenType.tNull, capture.Type);
        }
Beispiel #8
0
        public void PatternSearch9_LoopUntilAfterMatch()
        {
            var src = @"'Name': 'Znatoki' null 'ok'";

            var lxr = new JL(new StringSource(src));


            var capture = lxr.LazyFSM(
                (s, t) => s.LoopUntilAfterMatch(
                    (ss, tk) => tk.LoopUntilAny(JSONTokenType.tStringLiteral),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tColon),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tStringLiteral),
                    (ss, tk) => FSMI.TakeAndComplete
                    ),
                (s, t) => FSMI.Take
                );

            Aver.IsNotNull(capture);
            Aver.IsTrue(JSONTokenType.tNull == capture.Type);
        }
Beispiel #9
0
        public void PatternSearch7_LoopUntilAfterMatch()
        {
            var src = @"{a: 'Budilnik', 'Name': 'Znatoki', q: 2, z: 148, 'hero': 0x7f}";

            var lxr = new JL(new StringSource(src));


            var capture = lxr.LazyFSM(
                (s, t) => s.LoopUntilAfterMatch(
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tStringLiteral),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tColon),
                    (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tStringLiteral),
                    (ss, tk) => FSMI.TakeAndComplete
                    ),
                (s, t) => FSMI.Take
                );

            Aver.IsNotNull(capture);
            Aver.IsTrue(JSONTokenType.tComma == capture.Type);
        }
Beispiel #10
0
        public void PatternSearch10_LoopUntilAfterMatch()
        {
          var src = @"1,2,3,4,5,6,7,8,9 : 'Name': 'Znatoki' null 'ok'";

          var lxr = new JL(new StringSource(src));

                    
          var capture = lxr.LazyFSM(
                 (s,t) => s.LoopUntilAfterMatch(
                                            (ss, tk) => tk.LoopUntilAny(JSONTokenType.tStringLiteral),
                                            (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tColon),
                                            (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tStringLiteral),
                                            (ss, tk) => FSMI.TakeAndComplete
                                          ),
                 (s,t) => FSMI.Take
             );
        
          Assert.IsNotNull( capture );
          Assert.AreEqual( JSONTokenType.tNull, capture.Type );
        }
Beispiel #11
0
        public void PatternSearch7_LoopUntilAfterMatch()
        {
          var src = @"{a: 'Budilnik', 'Name': 'Znatoki', q: 2, z: 148, 'hero': 0x7f}";

          var lxr = new JL(new StringSource(src));

                    
          var capture = lxr.LazyFSM(
                 (s,t) => s.LoopUntilAfterMatch(
                                            (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tStringLiteral),
                                            (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tColon),
                                            (ss, tk) => tk.IsAnyOrAbort(JSONTokenType.tStringLiteral),
                                            (ss, tk) => FSMI.TakeAndComplete
                                          ),
                 (s,t) => FSMI.Take
             );
        
          Assert.IsNotNull( capture );
          Assert.AreEqual( JSONTokenType.tComma, capture.Type );
        }
Beispiel #12
0
        public void PatternSearch5_Skip()
        {
          var src = @"{a: 'Budilnik', 'Name': 'Znatoki', q:2, z: 148, 'hero': 0x7f}";

          var lxr = new JL(new StringSource(src));

                    
          var capture = lxr.LazyFSM(
                 (s,t) => s.Skip(1),
                 (s,t) => FSMI.Take
             );
        
          Assert.IsNotNull( capture );
          Assert.AreEqual( JSONTokenType.tIdentifier, capture.Type );
          Assert.AreEqual( "a", capture.Text );

          capture = lxr.LazyFSM(
                 (s,t) => s.Skip(9),
                 (s,t) => FSMI.Take
             );
        
          Assert.IsNotNull( capture );
          Assert.AreEqual( JSONTokenType.tIdentifier, capture.Type );
          Assert.AreEqual( "q", capture.Text );
        }
Beispiel #13
0
        public void PatternSearch3()
        {
          var src = @"{a: 2, b: 'Znatoki'}";

          var lxr = new JL(new StringSource(src));

                    
          var bvalue = lxr.LazyFSM(
                 (s,t) => t.LoopUntilAny("b"),
                 (s,t) => t.IsAnyOrAbort(JSONTokenType.tColon),
                 (s,t) => FSMI.Take,
                 (s,t) => t.IsAnyOrAbort(JSONTokenType.tComma)
             );
          
          Assert.AreEqual( null, bvalue );
        }
Beispiel #14
0
        public void PatternSearch()
        {
          var src = @"{a: 2, b: 'Znatoki', c: false, d: null, e: ['a','b','c']}";

          var lxr = new JL(new StringSource(src));

                    
          var bvalue = lxr.LazyFSM(
                 (s,t) => t.LoopUntilAny("b"),
                 (s,t) => t.IsAnyOrAbort(JSONTokenType.tColon),
                 (s,t) => FSMI.TakeAndComplete
             );
          
          Assert.AreEqual( "Znatoki", bvalue.Text );
        }