def test_cut2(self):
a, b, c, x = Var('a'), Var('b'), Var('c'), Var('x'),
assert_raises(NoSolutionFound, eval, letr([(a, function([[x], b(x)&cut&c(x)])),
(b, function([[1], True],
[[2], True],
[[3], True])),
(c, function([[2], True]))],
a(x), x))
def testCut1(self):
a, b, c, x = Var('a'), Var('b'), Var('c'), Var('x'),
eq_(eval(letr([(a, function([[x], b(x)&cut&c(x)])), #[cut] = cut = cut()
(b, function([[1], True],
[[2], True],
[[3], True])),
(c, function([[1], True]))],
a(x), x)), (1))
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)
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)
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)
def testCut4(self):
a, b, c, d, x = Var('a'), Var('b'), Var('c'), Var('d'), Var('x'),
eq_(eval(letr([(a, function([[x], b(x)&cut&c(x)],
[[x], d(x)])),
(b, function([[1], 'b1'],
[[4], 'b4'])),
(c, function([[4], 'c4'])),
(d, function([[3], 'd3']))],
a(x), x)), 3)
def test_cut2_no_Cut3_begin(self):
a, b, c, d, x = Var('a'), Var('b'), Var('c'), Var('d'), Var('x')
eq_(eval(letr([(a, function([[x], begin(b(x),c(x))],
[[x], d(x)])),
(b, function([[1], 'b1'],
[[4], 'b4'])),
(c, function([[4], 'c4'])),
(d, function([[3], 'd3']))],
a(x), x)), 4)
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(NoSolutionFound, eval, letr(ruleList, parse_text(s(x), '6'), x))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(s(x), ''), x))
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(NoSolutionFound, eval, letr(ruleList, parse_text(s(x), '3')))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(s(x), eoi), '12')))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(s(x), '')))
def testKleene1(self): #occurs_check
x, s, kleene = Var('x'), Var('s'), Var('kleene')
ruleList = [(s,function( ((x,), kleene(x)))),
(kleene,function(
((Cons('a', x),), and_p(char('a'), kleene(x))),
((nil,), nullword)))]
eq_(eval(letr(ruleList, parse_text(s(x), 'aa'), x)), L('a', 'a'))
eq_(eval(letr(ruleList, parse_text(s(x), ''), x)), nil)
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(s(x), eoi), '6'), x))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
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)
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)
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)
def testKleene1(self): #occurs_check
x, s, kleene = Var('x'), Var('s'), Var('kleene')
ruleList = [(s, function(((x, ), kleene(x)))),
(kleene,
function(((Cons('a', x), ), and_p(char('a'), kleene(x))),
((nil, ), nullword)))]
eq_(eval(letr(ruleList, parse_text(s(x), 'aa'), x)), L('a', 'a'))
eq_(eval(letr(ruleList, parse_text(s(x), ''), x)), nil)
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), '6'), x))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
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)
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(NoSolutionFound, eval,
letr(ruleList, parse_text(s(x), '6'), x))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(s(x), ''), x))
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(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(s(x), eoi), 'aab'), x))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(s(x), eoi), 'abc'), x))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
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)
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(NoSolutionFound, eval,
letr(ruleList, parse_text(s(x), '3')))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), '12')))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(s(x), '')))
def test_cut2_no_Cut2_and_(self):
# test_cut2_no_Cut_and_p work correct.
# but this test and test_cut2_no_Cut3_begin work wrong because the bug below:
# bug in Var.getvalue/Var.setvalue:
# dont't restore the longer chain of bindings after shorten it.
a, b, c, d, x = Var('a'), Var('b'), Var('c'), Var('d'), Var('x')
from dao.builtins.arith import and_
eq_(eval(letr([(a, function([[x], and_(b(x),c(x))],
[[x], d(x)])),
(b, function([[1], True],
[[4], True])),
(c, function([[4], True])),
(d, function([[3], True]))],
a(x), x)), 4)
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(NoSolutionFound, eval,
let(ruleList, parse_text(s(x), 'a'), x))
def test_chars(self):
x, cs, chars = Var('x'), Var('cs'), Var('chars')
eq_(
eval(
let([(chars, function(
((x, cs), and_p(char(x), contain(cs, x)))))],
parse_text(chars(x, 'a'), 'a'))), True)
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(NoSolutionFound, eval, letr([(f,function1)], parse_text(f(), 'a')))
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(NoSolutionFound, eval, letr(function1, parse_text(p(), '')))
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(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), 'aab'), x))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), 'abc'), x))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(s(x), eoi), '41'), x))
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'))
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'))
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(NoSolutionFound, eval,
begin(parse_text(function1(X), 'a'), X))
assert_raises(NoSolutionFound, eval,
begin(parse_text(and_p(function1(X), eoi), 'aaa'), X))
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(NoSolutionFound, eval,
letr([(f, function1)], parse_text(f(), 'a')))
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(NoSolutionFound, eval, letr(function1, parse_text(and_p(p(x), eoi), 'xy')))
assert_raises(NoSolutionFound, eval, letr(function1, parse_text(p(x), '')))
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(NoSolutionFound, eval,
letr(function1, parse_text(p(), '')))
def testDirectLeftRecursive(self):
#assert 0, 'temporary mask'
E = Var('E')
ruleList = [(E,function(
((), E()+char('a')),
((), char('b')),
))]
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)
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(NoSolutionFound, eval,
letr(function1, parse_text(and_p(p(x), eoi), 'xy')))
assert_raises(NoSolutionFound, eval,
letr(function1, parse_text(p(x), '')))
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)
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(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), '1+1/1'), e))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), '2'), e))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), '1/'), e))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), '/'), e))
assert_raises(NoSolutionFound, eval, letr(ruleList, parse_text(and_p(E(e, 1), eoi), ''), e))
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)
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)
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(
NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(E(e, 1), eoi), '1+1/1'), e))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(E(e, 1), eoi), '2'), e))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(E(e, 1), eoi), '1/'), e))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(E(e, 1), eoi), '/'), e))
assert_raises(NoSolutionFound, eval,
letr(ruleList, parse_text(and_p(E(e, 1), eoi), ''), e))
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)
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)
def test_chars(self):
x, cs,chars = Var('x'), Var('cs'), Var('chars')
eq_(eval(let([(chars, function(((x, cs), and_p(char(x), contain(cs, x)))))],
parse_text(chars(x, 'a'), 'a'))), True)
def test_closure3(self):
eq_(eval(let([(f, function([[x], prin(x)])),
(x, 1)],
f(x+x))), None)
def testletr(self): eq_(eval(letr([(f, function([[1], 1],[[x],f(x-1)]))], f(1))), 1) eq_(eval(letr([(f, function([[1], 1],[[x],f(x-1)]))], f(2))), 1)
def test_nongreedy_optional(self):
x, s = Var('x'), Var('s')
ruleList = [(s, function(((x, ), and_p(-char('a'), char(x)))))]
eq_(eval(let(ruleList, parse_text(s(x), 'a'), x)), 'a')
eq_(eval(let(ruleList, parse_text(s(x), 'aa'), x)), 'a')
eq_(eval(let(ruleList, parse_text(s(x), 'b'), x)), 'b')
def test_two_rule(self):
eq_(
eval(
letr([(f, function(((), char('a')), ((), char('b'))))],
parse_text(f(), 'a'), parse_text(f(), 'b'))), 'b')
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))
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'])
(sexpression1, sexpression, bracket_expression, punct_expression, sexpression_list,
atom, maybe_spaces, eval_parse_result) = vars(
'sexpression1, sexpression, bracket_expression, punct_expression, sexpression_list, '
'atom, maybe_spaces, eval_parse_result')
_ = DummyVar('_')
def from_sexp(var):
return from_(sexpression_module, var)
defines = in_module(sexpression_module,
define(atom, function(
([x], integer(x)),
([x], dqstring(x)),
([x], symbol(x))
)),
define(bracket_expression, function(
([exp_list], and_p(char('('), spaces0(_), from_sexp(sexpression_list)(exp_list), spaces0(_), char(')'))),
([exp_list], and_p(char('['), spaces0(_), from_sexp(sexpression_list)(exp_list), spaces0(_), char(']'))))),
define(punct_expression, function(
([L(quote, exp)], and_p(char("'"), from_sexp(sexpression)(exp))),
([L(quasiquote, exp)], and_p(char("`"), from_sexp(sexpression)(exp))),
([L(unquote_splice, exp)], and_p(literal(",@"), from_sexp(sexpression)(exp))),
([L(unquote, exp)], and_p(char(","), from_sexp(sexpression)(exp))))),
define(sexpression_list, function(
([Cons(exp, exp_list)], and_p(from_sexp(sexpression)(exp), from_sexp(maybe_spaces)(), from_sexp(sexpression_list)(exp_list))),
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))
def test_two_rule(self):
eq_(eval(letr([(f,function( ((),char('a')),((),char('b'))))],
parse_text(f(),'a'), parse_text(f(), 'b'))),
'b')
def test_nongreedy_optional(self):
x, s = Var('x'), Var('s')
ruleList =[(s, function( ((x,), and_p(-char('a'),char(x)))))]
eq_(eval(let(ruleList, parse_text(s(x), 'a'), x)), 'a')
eq_(eval(let(ruleList, parse_text(s(x), 'aa'), x)), 'a')
eq_(eval(let(ruleList, parse_text(s(x), 'b'), x)), 'b')
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(NoSolutionFound, eval, let(ruleList, parse_text(s(x), 'a'), x))
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'])
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(NoSolutionFound, eval, begin(parse_text(function1(X), 'a'), X))
assert_raises(NoSolutionFound, eval, begin(parse_text(and_p(function1(X), eoi), 'aaa'), X))
