Beispiel #1
0
 def test_digit_string0(self):
   x = LogicVar('x')
   eq_(eval(parse_text(digits0, '')), '')
   eq_(eval(parse_text(digits0, 'a')), '')
   eq_(eval(parse_text(digits0, '123')), '123')
   eq_(eval(parse_text(is_(x, digits0), '123a')), '123')
   eq_(eval(begin(parse_text(eval_unify(x, digits0), '123 '), getvalue(x))), '123')
Beispiel #2
0
 def test_digit_string1(self):
     x = LogicVar('x')
     eq_(eval(parse_text(digits1, '123')), '123')
     eq_(eval(parse_text(is_(x, digits1), '123a')), '123')
     eq_(
         eval(begin(parse_text(eval_unify(x, digits1), '123 '),
                    getvalue(x))), '123')
Beispiel #3
0
 def test_some2(self):
     X = Var('X')
     eq_(eval(parse_text(and_p(some(char(X)), char('4')), '224')), '4')
     eq_(eval(parse_text(and_p(some(char(X)), cut, char('4')), '224')), '4')
     assert_raises(
         NoSolution, eval,
         parse_text(and_p(some(char(X)), char('3'), char('5')), '2234'))
Beispiel #4
0
 def test_some(self):
     X, Y = Var('X'), Var('Y')
     eq_(eval(begin(parse_text(some(char(X), X, Y), '222'), Y)),
         ['2', '2', '2'])
     eq_(eval(begin(parse_text(some(char(X), X, Y), '234'), Y)), ['2'])
     assert_raises(NoSolution, eval,
                   begin(parse_text(some(char(X), X, Y), ''), Y))
Beispiel #5
0
 def testoptionalcut(self):
     x, s = Var('x'), Var('s')
     ruleList = [(s, function(((x, ), and_p(-char('a'), cut, char(x)))))]
     eq_(eval(let(ruleList, parse_text(s(x), 'aa'), x)), 'a')
     eq_(eval(let(ruleList, parse_text(s(x), 'b'), x)), 'b')
     assert_raises(NoSolution, eval, let(ruleList, parse_text(s(x), 'a'),
                                         x))
Beispiel #6
0
 def test_right_recursive2(self):
   x, p = Var('x'), Var('p')
   function1 = [(p,function( ((), and_p(char(x), p())),
                    ((),char(x))))]
   eq_(eval(letr(function1, parse_text(p(),'a'), parse_text(p(),'ab'), parse_text(p(),'abc'))),
       'c')
   assert_raises(NoSolution, eval, letr(function1, parse_text(p(), '')))
Beispiel #7
0
 def test_dummy_times_between(self):
   _, Y = DummyVar('_'), Var('Y')
   eq_(eval(begin(parse_text(times_between(char(_), 2, 3, _, Y), '234'), Y)), ['2','3', '4'])
   eq_(eval(begin(parse_text(times_between(char(_), 2, 3, _, Y), '23'), Y)), ['2','3'])
   eq_(eval(begin(parse_text(times_between(char(_), 2, 3, _, Y), '2345'), Y)), ['2','3', '4'])
   assert_raises(NoSolution, eval, begin(parse_text(times_between(char(_), 2, 3, _, Y), '2'), Y))
   assert_raises(NoSolution, eval, begin(parse_text((and_p, times_between(char(_), 2, 3, _, Y), eoi), '2345'), Y))
Beispiel #8
0
 def test_dummy_any(self):
     _, Y = DummyVar('_'), Var('Y')
     eq_(eval(begin(parse_text(any(char(_), _, Y), '222'), Y)),
         ['2', '2', '2'])
     eq_(eval(begin(parse_text(any(char(_), _, Y), '234'), Y)),
         ['2', '3', '4'])
     eq_(eval(begin(parse_text(any(char(_), _, Y), ''), Y)), [])
Beispiel #9
0
 def test_right_recursive1(self):
   function1 = function( ((), and_p(char('a'), f())),
                    ((),char('b')))
   eq_(eval(letr([(f,function1)], 
              parse_text(f(),'b'), parse_text(f(),'ab'), parse_text(f(),'aab'))), 
       'b')
   assert_raises(NoSolution, eval, letr([(f,function1)], parse_text(f(), 'a')))
Beispiel #10
0
 def test_right_recursive1(self):
     function1 = function(((), and_p(char('a'), f())), ((), char('b')))
     eq_(
         eval(
             letr([(f, function1)], parse_text(f(), 'b'),
                  parse_text(f(), 'ab'), parse_text(f(), 'aab'))), 'b')
     assert_raises(NoSolution, eval,
                   letr([(f, function1)], parse_text(f(), 'a')))
Beispiel #11
0
 def test_underline_letter_digit(self):
     x = LogicVar('x')
     eq_(eval(parse_text(underline_letter_digit, '1')), '1')
     eq_(eval(parse_text(is_(x, underline_letter_digit), 'a')), 'a')
     eq_(
         eval(
             begin(parse_text(eval_unify(x, underline_letter_digit), '_'),
                   getvalue(x))), '_')
Beispiel #12
0
 def test_unify_right_recursive(self):
   x, p = Var('x'), Var('p')
   function1 = [(p,function( ((x,), and_p(char(x), p(x))),
                         ((x,),char(x))))]
   eq_(eval(letr(function1, parse_text(p(x), 'aa'))), 'a')
   eq_(eval(letr(function1, parse_text(p(x), 'a'))), 'a')
   assert_raises(NoSolution, eval, letr(function1, parse_text(and_p(p(x), eoi), 'xy')))
   assert_raises(NoSolution, eval, letr(function1, parse_text(p(x), '')))
Beispiel #13
0
 def test_times_a2(self):
     X, Y, S = Var('X'), Var('Y'), Var('S')
     function1 = function(((Y, ), times(char('a'), 2, 'a', Y)))
     eq_(eval(begin(parse_text(function1(X), 'aa'), X)), ['a', 'a'])
     assert_raises(NoSolution, eval, begin(parse_text(function1(X), 'a'),
                                           X))
     assert_raises(NoSolution, eval,
                   begin(parse_text(and_p(function1(X), eoi), 'aaa'), X))
Beispiel #14
0
 def test_right_recursive2(self):
     x, p = Var('x'), Var('p')
     function1 = [(p, function(((), and_p(char(x), p())), ((), char(x))))]
     eq_(
         eval(
             letr(function1, parse_text(p(), 'a'), parse_text(p(), 'ab'),
                  parse_text(p(), 'abc'))), 'c')
     assert_raises(NoSolution, eval, letr(function1, parse_text(p(), '')))
Beispiel #15
0
 def test_dummy_times_more(self):
     _, Y = DummyVar('_'), Var('Y')
     eq_(eval(begin(parse_text((times_more, char(_), 3, _, Y), '234'), Y)),
         ['2', '3', '4'])
     eq_(eval(begin(parse_text((times_more, char(_), 3, _, Y), '2345'), Y)),
         ['2', '3', '4', '5'])
     assert_raises(NoSolution, eval,
                   begin(parse_text(times_more(char(_), 3, _, Y), '23'), Y))
Beispiel #16
0
 def test_dumy_some(self):
     _, Y = DummyVar('_'), Var('Y')
     eq_(eval(begin(parse_text(some(char(_), _, Y), '222'), Y)),
         ['2', '2', '2'])
     eq_(eval(begin(parse_text(some(char(_), _, Y), '234'), Y)),
         ['2', '3', '4'])
     assert_raises(NoSolution, eval,
                   begin(parse_text(some(char(_), _, Y), ''), Y))
Beispiel #17
0
 def testIndentUndent(self):
   _, n, s, line = DummyVar('_'), Var('n'), Var('s'), Var('line')
   space = char(' ')
   ruleList = [(s,function( ((n,), some(line(n)),s(add(n,1))),
                           ((n,), some(line(n))))),
               (line,function( ((n,), times(space, n),some(letter(_)),any(space),char('\n'))))
               ]
   eq_(eval(letr(ruleList, parse_text(s(0),  'a\n b\n c\n'))), True)
   eq_(eval(letr(ruleList, parse_text(s(0),  'asd\n bdf\n cdfh\n'))), True)    
Beispiel #18
0
 def testparallelRule(self):
   x, s, gt, lt = Var('x'), Var('s'), Var('>'), Var('<')
   ruleList = [(s,function( ((x,), parallel(gt(x, 3), lt(x, 5))))),
               (gt,function( ((4, 3),char('4')))),
               (lt,function( ((4, 5),char('4'))))]
   eq_(eval(letr(ruleList, parse_text(s(x), '4'), x)), 4)
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), '6'), x))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), ''), x))
Beispiel #19
0
 def test_unify_right_recursive(self):
     x, p = Var('x'), Var('p')
     function1 = [(p,
                   function(((x, ), and_p(char(x), p(x))),
                            ((x, ), char(x))))]
     eq_(eval(letr(function1, parse_text(p(x), 'aa'))), 'a')
     eq_(eval(letr(function1, parse_text(p(x), 'a'))), 'a')
     assert_raises(NoSolution, eval,
                   letr(function1, parse_text(and_p(p(x), eoi), 'xy')))
     assert_raises(NoSolution, eval, letr(function1, parse_text(p(x), '')))
Beispiel #20
0
 def testOr(self):
   x, s, one, two = Var('x'), Var('s'), Var('one'), Var('two')
   ruleList = [(s, function( ((x,), or_p(one(x), two(x))))),
               (one, function( (('1',),char('1')))),
               (two, function( (('2',),char('2'))))]
   eq_(eval(letr(ruleList, parse_text(s(x), '1'))), '1')
   eq_(eval(letr(ruleList, parse_text(s(y),  '2'))), '2')         
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), '3')))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(s(x), eoi), '12')))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), '')))
Beispiel #21
0
 def testIndirectLeftRecursive(self):
   #assert 0, 'temporary mask'
   A, B, C = vars('A, B, C')
   ruleList = [(A, function(((), B()))), 
               (B, function(
                     ((), A()+char('a')),
                      ((), char('b')),
                    ))]
   eq_(eval(letr(ruleList, parse_text(A()+eoi,  'b'))), True)
   eq_(eval(letr(ruleList, parse_text(A()+eoi,  'ba'))), True)
   eq_(eval(letr(ruleList, parse_text(A()+eoi,  'baa'))), True)
Beispiel #22
0
 def testIndirectLeftRecursive(self):
     #assert 0, 'temporary mask'
     A, B, C = vars('A, B, C')
     ruleList = [(A, function(((), B()))),
                 (B, function(
                     ((), A() + char('a')),
                     ((), char('b')),
                 ))]
     eq_(eval(letr(ruleList, parse_text(A() + eoi, 'b'))), True)
     eq_(eval(letr(ruleList, parse_text(A() + eoi, 'ba'))), True)
     eq_(eval(letr(ruleList, parse_text(A() + eoi, 'baa'))), True)
Beispiel #23
0
 def testOr(self):
     x, s, one, two = Var('x'), Var('s'), Var('one'), Var('two')
     ruleList = [(s, function(((x, ), or_p(one(x), two(x))))),
                 (one, function((('1', ), char('1')))),
                 (two, function((('2', ), char('2'))))]
     eq_(eval(letr(ruleList, parse_text(s(x), '1'))), '1')
     eq_(eval(letr(ruleList, parse_text(s(y), '2'))), '2')
     assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), '3')))
     assert_raises(NoSolution, eval,
                   letr(ruleList, parse_text(and_p(s(x), eoi), '12')))
     assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), '')))
Beispiel #24
0
 def testIndentUndent(self):
     _, n, s, line = DummyVar('_'), Var('n'), Var('s'), Var('line')
     space = char(' ')
     ruleList = [(s,
                  function(((n, ), some(line(n)), s(add(n, 1))),
                           ((n, ), some(line(n))))),
                 (line,
                  function(((n, ), times(space, n), some(letter(_)),
                            any(space), char('\n'))))]
     eq_(eval(letr(ruleList, parse_text(s(0), 'a\n b\n c\n'))), True)
     eq_(eval(letr(ruleList, parse_text(s(0), 'asd\n bdf\n cdfh\n'))), True)
Beispiel #25
0
 def test_dummy_seplist(self):
     _, Y = DummyVar('_'), Var('Y')
     eq_(
         eval(
             begin(parse_text(seplist(char(_), char(','), _, Y), '2,2,2'),
                   Y)), ['2', '2', '2'])
     eq_(
         eval(
             begin(parse_text(seplist(char(_), char(','), _, Y), '2,3,4'),
                   Y)), ['2', '3', '4'])
     eq_(eval(begin(parse_text(seplist(char(_), char(','), _, Y), '2'), Y)),
         ['2'])
Beispiel #26
0
 def testparallelRule(self):
     x, s, gt, lt = Var('x'), Var('s'), Var('>'), Var('<')
     ruleList = [(s, function(((x, ), parallel(gt(x, 3), lt(x, 5))))),
                 (gt, function(((4, 3), char('4')))),
                 (lt, function(((4, 5), char('4'))))]
     eq_(eval(letr(ruleList, parse_text(s(x), '4'), x)), 4)
     assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), '6'),
                                          x))
     assert_raises(NoSolution, eval,
                   letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
     assert_raises(NoSolution, eval, letr(ruleList, parse_text(s(x), ''),
                                          x))
Beispiel #27
0
 def test_seplist(self):
     X, Y = Var('X'), Var('Y')
     eq_(
         eval(
             begin(parse_text(seplist(char(X), char(','), X, Y), '2,2,2'),
                   Y)), ['2', '2', '2'])
     eq_(
         eval(
             begin(parse_text(seplist(char(X), char(','), X, Y), '2,3,4'),
                   Y)), ['2'])
     eq_(eval(begin(parse_text(seplist(char(X), char(','), X, Y), '2'), Y)),
         ['2'])
     eq_(eval(begin(parse_text(seplist(char(X), char(','), X, Y), ''), Y)),
         [])
Beispiel #28
0
 def testRecursiveReturnValue3(self):
     E, e, e1, e2 = Var('E'), Var('e'), Var('e1'), Var('e2')
     ruleList = [(E,
                  function(((e, 1), E(e, 2)), ((e, 2), char(e)),
                           (((e1, e2), 1), E(e1, 2), E(e2, 1))))]
     eq_(eval(letr(ruleList, parse_text(E(e, 1) + eoi, '12'), e)),
         ('1', '2'))
Beispiel #29
0
 def test_chars(self):
     x, cs, chars = LogicVar('x'), Var('cs'), MacroVar('chars')
     x1 = Var('x')
     eq_(
         eval(
             let([(chars, lamda(
                 (x1, cs), begin(char(x1), contain(cs, x1))))],
                 parse_text(chars(x, 'a'), 'a'), getvalue(x))), 'a')
Beispiel #30
0
 def testABCD(self):
   A, B, C, D = vars('A, B, C, D')
   ruleList = [(A,function(((), B()|C()))), 
               (B,function(((), D()+char('b')))), 
               (C,function(((), D()+char('c')))), 
               (D,function(((), char('d')))), 
              ]
   eq_(eval(letr(ruleList, parse_text(A()+eoi,  'dc'))), True)
Beispiel #31
0
 def testRecursiveReturnValue3(self):
   E, e, e1, e2 = Var('E'), Var('e'), Var('e1'), Var('e2')  
   ruleList = [(E,function( 
                    ((e, 1), E(e, 2)),
                    ((e, 2), char(e)),
                    (((e1, e2), 1), E(e1,2), E(e2, 1))
                        ))]
   eq_(eval(letr(ruleList, parse_text(E(e, 1)+eoi, '12'), e)), ('1', '2'))
Beispiel #32
0
 def testDirectLeftRecursive(self):
   #assert 0, 'temporary mask'
   E = Var('E')
   ruleList = [(E,function( 
                    ((), #println('e1'), 
                         E(), 
                         #println('e2'), 
                         char('a'), 
                         #println('e3')
                         ),
                    ((), char('b'), 
                         #println('eb')
                         ),
                    ))]
   eq_(eval(letr(ruleList, parse_text(E()+eoi,  'b'))), True)
   eq_(eval(letr(ruleList, parse_text(E()+eoi,  'ba'))), True)
   eq_(eval(letr(ruleList, parse_text(E()+eoi,  'baa'))), True)
Beispiel #33
0
 def test_any_some(self):
     X, Y = Var('X'), Var('Y')
     eq_(
         eval(
             begin(
                 parse_text(
                     char(X) + any(~char('b') + some(char(X))) + eoi,
                     'abaaaa'), X)), 'a')
Beispiel #34
0
 def testABCD(self):
     A, B, C, D = vars('A, B, C, D')
     ruleList = [
         (A, function(((), B() | C()))),
         (B, function(((), D() + char('b')))),
         (C, function(((), D() + char('c')))),
         (D, function(((), char('d')))),
     ]
     eq_(eval(letr(ruleList, parse_text(A() + eoi, 'dc'))), True)
Beispiel #35
0
 def testKleene1(self): #occurs_check
   x, s, kleene = Var('x'), Var('s'), Var('kleene')
   x1 = Var('x')
   result = LogicVar('result')
   ruleList = [(kleene, rules( 
                 ((cons('a', x),), begin(char('a'), kleene(x))),
                 ((nil,), nullword)))]
   eq_(eval(letrec(ruleList, 
                   parse_text(kleene(result), 'aa'), getvalue(result))), L('a', 'a'))
Beispiel #36
0
 def test_dummy_times_less(self):
     _, Y = DummyVar('_'), Var('Y')
     eq_(
         eval(
             preparse(
                 begin(
                     parse_text(
                         times_less(char(_), 3, _, Y) + char('4'), '234'),
                     Y))), ['2', '3'])
     eq_(eval(begin(parse_text(times_less(char(_), 3, _, Y), '234'), Y)),
         ['2', '3', '4'])
     eq_(eval(begin(parse_text(times_less(char(_), 3, _, Y), '23'), Y)),
         ['2', '3'])
     assert_raises(
         NoSolution, eval,
         preparse(
             begin(parse_text(times_less(char(_), 3, _, Y) + eoi, '2345'),
                   Y)))
Beispiel #37
0
 def test_dummy_times_less_lazy(self):
     _, Y = DummyVar('_'), Var('Y')
     eq_(
         eval(
             preparse(
                 begin(
                     parse_text(
                         times_less(char(_), 3, _, Y, lazy) + char('4'),
                         '234'), Y))), ['2', '3'])
Beispiel #38
0
 def testKleene1(self):  #occurs_check
     x, s, kleene = Var('x'), Var('s'), Var('kleene')
     x1 = Var('x')
     result = LogicVar('result')
     ruleList = [(kleene,
                  rules(((cons('a', x), ), begin(char('a'), kleene(x))),
                        ((nil, ), nullword)))]
     eq_(
         eval(
             letrec(ruleList, parse_text(kleene(result), 'aa'),
                    getvalue(result))), L('a', 'a'))
Beispiel #39
0
 def test_dummy_times_between(self):
     _, Y = DummyVar('_'), Var('Y')
     eq_(
         eval(
             begin(parse_text(times_between(char(_), 2, 3, _, Y), '234'),
                   Y)), ['2', '3', '4'])
     eq_(
         eval(begin(parse_text(times_between(char(_), 2, 3, _, Y), '23'),
                    Y)), ['2', '3'])
     eq_(
         eval(
             begin(parse_text(times_between(char(_), 2, 3, _, Y), '2345'),
                   Y)), ['2', '3', '4'])
     assert_raises(
         NoSolution, eval,
         begin(parse_text(times_between(char(_), 2, 3, _, Y), '2'), Y))
     assert_raises(
         NoSolution, eval,
         begin(
             parse_text((and_p, times_between(char(_), 2, 3, _, Y), eoi),
                        '2345'), Y))
Beispiel #40
0
 def testExpressionByRightRecursiveList(self):
   E, e, e1, e2 = Var('E'), Var('e'), Var('e1'), Var('e2')  
   ruleList = [(E,function( 
                    (((e1, '/', e2), 1), E(e1,2), char('/'), E(e2, 1)),
                    ((1, 2), char('1')),
                    ((e, 1), E(e, 2))))]
   eq_(eval(letr(ruleList, parse_text(E(e, 1),  '1/1/1'), e)), (1, '/', (1, '/', 1)))
   eq_(eval(letr(ruleList, parse_text(E(e, 1),  '1/1'), e)), (1, '/', 1))
   eq_(eval(letr(ruleList, parse_text(E(e, 1),  '1'), e)), 1)
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), '1+1/1'), e))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), '2'), e))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), '1/'), e))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), '/'), e))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), ''), e))
Beispiel #41
0
 def testDirectLeftRecursive(self):
     #assert 0, 'temporary mask'
     E = Var('E')
     ruleList = [(
         E,
         function(
             (
                 (),  #println('e1'), 
                 E(),
                 #println('e2'),
                 char('a'),
                 #println('e3')
             ),
             (
                 (),
                 char('b'),
                 #println('eb')
             ),
         ))]
     eq_(eval(letr(ruleList, parse_text(E() + eoi, 'b'))), True)
     eq_(eval(letr(ruleList, parse_text(E() + eoi, 'ba'))), True)
     eq_(eval(letr(ruleList, parse_text(E() + eoi, 'baa'))), True)
Beispiel #42
0
 def testKleene2(self):
   x, c, s, kleene = Var('x'), Var('c'), Var('s'), Var('kleene')
   ruleList = [(s,function( ((x,), kleene(c, x)))),
               (kleene,function( 
                 ((c, Cons(c, x)), and_p(char(c), kleene(c, x))),
                 ((c, nil), nullword)))]
   eq_(eval(letr(ruleList, parse_text(s(x), 'aa'), x)), L('a', 'a'))
   eq_(eval(letr(ruleList, parse_text(s(x), 'aaa'), x)), L('a', 'a', 'a'))
   eq_(eval(letr(ruleList, parse_text(s(x), 'bbb'), x)), L('b', 'b', 'b'))
   eq_(eval(letr(ruleList, parse_text(s(x), ''), x)), nil)
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(s(x), eoi), 'aab'), x))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(s(x), eoi), 'abc'), x))
   assert_raises(NoSolution, eval, letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
Beispiel #43
0
 def testKleene3(self):
   x, c, kleene = Var('x'), Var('c'), Var('kleene')
   ruleList = [(kleene,function( 
                 ((Cons(c, x),), char(c),kleene(x)),
                 ((nil,), nullword)))]
   eq_(eval(letr(ruleList, parse_text(kleene(x), 'a'), x)), L('a'))
   eq_(eval(letr(ruleList, parse_text(kleene(x), 'aa'), x)), L('a', 'a'))
   eq_(eval(letr(ruleList, parse_text(kleene(x), 'aaa'), x)), L('a', 'a', 'a'))
   eq_(eval(letr(ruleList, parse_text(kleene(x), 'bbb'), x)), L('b', 'b', 'b'))
   eq_(eval(letr(ruleList, parse_text(kleene(x), 'abc'), x)), L('a', 'b', 'c'))
   eq_(eval(letr(ruleList, parse_text(kleene(x), ''), x)), nil)
Beispiel #44
0
 def testDirectLeftRecursiveWithArguments(self):
   #assert 0, 'temporary mask'
   E, X = Var('E'), Var('X')
   ruleList = [(E,function( 
                    ((), #println('e1'), 
                         E(), 
                         #println('e2'), 
                         digit(X), 
                         #println('e3', X)
                         ),
                    ((), char('b'), 
                         #println('eb')
                         ),
                    ))]
   #eq_(eval(letr(ruleList, parse_text(E()+eoi,  'b'))), True)
   #eq_(eval(letr(ruleList, parse_text(E()+eoi,  'b1'))), True)
   eq_(eval(letr(ruleList, parse_text(E()+eoi,  'b123'))), True)
Beispiel #45
0
 def testKleene4(self):
   x, _, c, s, kleene = Var('x'), DummyVar('_'), Var('c'), Var('s'), Var('kleene')
   ruleList = [(s,function( ((x,), kleene(_, x)))),
               (kleene,function( 
                 ((_, Cons(c, x)), char(c)&kleene(_, x)),
                 ((_, nil), nullword)))]
   eq_(eval(letr(ruleList, parse_text(s(x), 'a'), x)), L('a'))
   eq_(eval(letr(ruleList, parse_text(s(x), 'aa'), x)), L('a', 'a'))
   eq_(eval(letr(ruleList, parse_text(s(x), 'aaa'), x)), L('a', 'a', 'a'))
   eq_(eval(letr(ruleList, parse_text(s(x), 'bbb'), x)), L('b', 'b', 'b'))
   eq_(eval(letr(ruleList, parse_text(s(x), 'abc'), x)), L('a', 'b', 'c'))
   eq_(eval(letr(ruleList, parse_text(s(x), ''), x)), nil)
Beispiel #46
0
 def testKleene2(self):
     x, c, s, kleene = Var('x'), Var('c'), Var('s'), Var('kleene')
     ruleList = [(s, function(((x, ), kleene(c, x)))),
                 (kleene,
                  function(((c, Cons(c, x)), and_p(char(c), kleene(c, x))),
                           ((c, nil), nullword)))]
     eq_(eval(letr(ruleList, parse_text(s(x), 'aa'), x)), L('a', 'a'))
     eq_(eval(letr(ruleList, parse_text(s(x), 'aaa'), x)), L('a', 'a', 'a'))
     eq_(eval(letr(ruleList, parse_text(s(x), 'bbb'), x)), L('b', 'b', 'b'))
     eq_(eval(letr(ruleList, parse_text(s(x), ''), x)), nil)
     assert_raises(NoSolution, eval,
                   letr(ruleList, parse_text(and_p(s(x), eoi), 'aab'), x))
     assert_raises(NoSolution, eval,
                   letr(ruleList, parse_text(and_p(s(x), eoi), 'abc'), x))
     assert_raises(NoSolution, eval,
                   letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
Beispiel #47
0
 def testKleene4(self):
     x, _, c, s, kleene = Var('x'), DummyVar('_'), Var('c'), Var('s'), Var(
         'kleene')
     ruleList = [(s, function(((x, ), kleene(_, x)))),
                 (kleene,
                  function(((_, Cons(c, x)), char(c) & kleene(_, x)),
                           ((_, nil), nullword)))]
     eq_(eval(letr(ruleList, parse_text(s(x), 'a'), x)), L('a'))
     eq_(eval(letr(ruleList, parse_text(s(x), 'aa'), x)), L('a', 'a'))
     eq_(eval(letr(ruleList, parse_text(s(x), 'aaa'), x)), L('a', 'a', 'a'))
     eq_(eval(letr(ruleList, parse_text(s(x), 'bbb'), x)), L('b', 'b', 'b'))
     eq_(eval(letr(ruleList, parse_text(s(x), 'abc'), x)), L('a', 'b', 'c'))
     eq_(eval(letr(ruleList, parse_text(s(x), ''), x)), nil)
Beispiel #48
0
 def testExpressionByRightRecursiveList(self):
     E, e, e1, e2 = Var('E'), Var('e'), Var('e1'), Var('e2')
     ruleList = [(E,
                  function(
                      (((e1, '/', e2), 1), E(e1, 2), char('/'), E(e2, 1)),
                      ((1, 2), char('1')), ((e, 1), E(e, 2))))]
     eq_(eval(letr(ruleList, parse_text(E(e, 1), '1/1/1'), e)),
         (1, '/', (1, '/', 1)))
     eq_(eval(letr(ruleList, parse_text(E(e, 1), '1/1'), e)), (1, '/', 1))
     eq_(eval(letr(ruleList, parse_text(E(e, 1), '1'), e)), 1)
     assert_raises(
         NoSolution, eval,
         letr(ruleList, parse_text(and_p(E(e, 1), eoi), '1+1/1'), e))
     assert_raises(NoSolution, eval,
                   letr(ruleList, parse_text(and_p(E(e, 1), eoi), '2'), e))
     assert_raises(NoSolution, eval,
                   letr(ruleList, parse_text(and_p(E(e, 1), eoi), '1/'), e))
     assert_raises(NoSolution, eval,
                   letr(ruleList, parse_text(and_p(E(e, 1), eoi), '/'), e))
     assert_raises(NoSolution, eval,
                   letr(ruleList, parse_text(and_p(E(e, 1), eoi), ''), e))
Beispiel #49
0
 def test_dummy_seplist(self):
   _, Y = DummyVar('_'), Var('Y')
   eq_(eval(begin(parse_text(seplist(char(_), char(','), _, Y), '2,2,2'), Y)), ['2','2','2'])
   eq_(eval(begin(parse_text(seplist(char(_), char(','), _, Y), '2,3,4'), Y)), ['2', '3', '4'])
   eq_(eval(begin(parse_text(seplist(char(_), char(','), _, Y), '2'), Y)), ['2'])
Beispiel #50
0
 def test_dumy_some(self):
   _, Y = DummyVar('_'), Var('Y')
   eq_(eval(begin(parse_text(some(char(_), _, Y), '222'), Y)), ['2','2','2'])
   eq_(eval(begin(parse_text(some(char(_), _, Y), '234'), Y)),['2', '3', '4'])
   assert_raises(NoSolution, eval, begin(parse_text(some(char(_), _, Y), ''), Y))
Beispiel #51
0
 def testRecursiveReturnValue2(self):
   E, F, e, e1 = Var('E'), Var('F'), Var('e'), Var('e1')
   ruleList = [(E,function((((e, e),), F(e)))),
               (F,function(((1,), char('1'))))]
   eq_(eval(letr(ruleList, parse_text(E(e),  '1'), e)), (1, 1))
Beispiel #52
0
 def test_dummy_times(self):
   _, Y = DummyVar('_'), Var('Y')
   eq_(eval(begin(parse_text(times(char(_), 3, _, Y), '234'), Y)), ['2','3','4'])
Beispiel #53
0
 def test_times(self):
   X, Y = Var('X'), Var('Y')
   eq_(eval(begin(parse_text(times(char(X), 3, X, Y), '222'), Y)), ['2','2','2'])
   assert_raises(NoSolution, eval, parse_text(times(char(X), 3, X, Y), '2234'))
Beispiel #54
0
 def test_dummy_times_more(self):
   _, Y = DummyVar('_'), Var('Y')
   eq_(eval(begin(parse_text((times_more,char(_), 3, _, Y), '234'), Y)), ['2','3','4'])
   eq_(eval(begin(parse_text((times_more,char(_), 3, _, Y), '2345'), Y)), ['2','3','4', '5'])
   assert_raises(NoSolution, eval, begin(parse_text(times_more(char(_), 3, _, Y), '23'), Y))
Beispiel #55
0
 def test_dummy_times_less(self):
   _, Y = DummyVar('_'), Var('Y')
   eq_(eval(preparse(begin(parse_text(times_less(char(_), 3, _, Y)+char('4'), '234'), Y))), ['2','3'])
   eq_(eval(begin(parse_text(times_less(char(_), 3, _, Y), '234'), Y)), ['2','3','4'])
   eq_(eval(begin(parse_text(times_less(char(_), 3, _, Y), '23'), Y)), ['2','3'])
   assert_raises(NoSolution, eval, preparse(begin(parse_text(times_less(char(_), 3, _, Y)+eoi, '2345'), Y)))
Beispiel #56
0
 def test_dummy_times_less_lazy(self):
   _, Y = DummyVar('_'), Var('Y')
   eq_(eval(preparse(begin(parse_text(times_less(char(_), 3, _, Y, lazy)+char('4'), '234'), Y))), ['2','3'])
Beispiel #57
0
 def test_times_a2(self): 
   X, Y, S = Var('X'), Var('Y'), Var('S')
   function1 = function(((Y,), times(char('a'), 2, 'a', Y)))
   eq_(eval(begin(parse_text(function1(X),'aa'), X)), ['a', 'a'])
   assert_raises(NoSolution, eval, begin(parse_text(function1(X), 'a'), X))
   assert_raises(NoSolution, eval, begin(parse_text(and_p(function1(X), eoi), 'aaa'), X))
Beispiel #58
0
 def test_times_an(self): 
   X, Y, S, n = Var('X'), Var('Y'), Var('S'), Var('n')
   function1 = function( ((Y,), times(char('a'), n, 'a', Y)))
   eq_(eval(begin(parse_text(function1(X), 'a'), X)), ['a'])
   eq_(eval(begin(parse_text(function1(X), 'aa'), X)), ['a', 'a'])
   eq_(eval(begin(parse_text(function1(X), 'aaa'), X)), ['a', 'a', 'a'])
Beispiel #59
0
 def test_seplist(self):
   X, Y = Var('X'), Var('Y')
   eq_(eval(begin(parse_text(seplist(char(X), char(','), X, Y), '2,2,2'), Y)), ['2','2','2'])
   eq_(eval(begin(parse_text(seplist(char(X), char(','), X, Y), '2,3,4'), Y)), ['2'])
   eq_(eval(begin(parse_text(seplist(char(X), char(','), X, Y), '2'), Y)), ['2'])
   eq_(eval(begin(parse_text(seplist(char(X), char(','), X, Y), ''), Y)), [])
Beispiel #60
0
 def test_chars(self):
   x, cs, chars = LogicVar('x'), Var('cs'), MacroVar('chars')
   x1 = Var('x')
   eq_(eval(let([(chars, lamda((x1, cs), begin(char(x1), contain(cs, x1))))],
                           parse_text(chars(x, 'a'), 'a'), getvalue(x))), 'a')