class TestParseCase(unittest.TestCase):
'''testing with RPNEmitter'''
def setUp(self):
self.parser = REParser(RPNStringEmitter())
def test_Empty(self):
self.assertEqual(self.parser.parse(''), '')
def test_a(self):
self.assertEqual(self.parser.parse('a'), 'a')
def test_b(self):
self.assertEqual(self.parser.parse('b'), 'b')
def test_a_multi(self):
self.assertEqual(self.parser.parse('a*'), 'a*')
def test_cat_ab(self):
self.assertEqual(self.parser.parse('ab'), 'ab+')
def test_cat_abc(self):
self.assertEqual(self.parser.parse('abc'), 'ab+c+')
def test_LP_ab_RP_c(self):
self.assertEqual(self.parser.parse('(ab)c'), 'ab+c+')
def test_LP_a_RP(self):
self.assertEqual(self.parser.parse('(a)'), 'a')
def test_LPLP_a_RPRP(self):
self.assertEqual(self.parser.parse('((a))'), 'a')
def test_a_cat_a_or_b(self):
self.assertEqual(self.parser.parse('aa|b'), 'aa+b|')
def test_LP_aa_RP_or_b(self):
self.assertEqual(self.parser.parse('(aa)|b'), 'aa+b|')
def test_a_LP_a_or_b_RP(self):
self.assertEqual(self.parser.parse('a(a|b)'), 'aab|+')
def test_amutli_or_b(self):
self.assertEqual(self.parser.parse('a*|b'), 'a*b|')
def test_escapse(self):
self.assertEqual(self.parser.parse('\|'), '\|')
def test_escapse2(self):
self.assertEqual(self.parser.parse('\|a'), '\|a+')
def test_a_or_bmutli(self):
self.assertEqual(self.parser.parse('a|b*'), 'ab*|')
def test_LP_a_or_b_RP_mutli(self):
self.assertEqual(self.parser.parse('(a|b)*'), 'ab|*')
def test_a_or_b_or_c(self):
self.assertEqual(self.parser.parse('a|b|c'), 'ab|c|')
def test_LP_a_m_RP_m(self):
self.assertEqual(self.parser.parse('(a*)*'), 'a**')
def xtest_a_mm(self):
'''
>>> import re
>>> r = re.compile('a**')
would fail.
'''
self.assertEqual(self.parser.parse('a**'), 'a**')
def test_LP_a_RP_b(self):
self.assertEqual(self.parser.parse('(a)b'), 'ab+')
def test_LP_a_m_RP_b(self):
self.assertEqual(self.parser.parse('(a)*b'), 'a*b+')
def test_LP_a_m_RP_b_b(self):
self.assertEqual(self.parser.parse('(a)*bb'), 'a*b+b+')
def test_LP_LP_a_m_RP_b_RP_b(self):
self.assertEqual(self.parser.parse('((a)*b)b'), 'a*b+b+')
def test_aa_LP_a_or_b_RP(self):
self.assertEqual(self.parser.parse('(aa)(a|b)'), 'aa+ab|+')
def test_aa_LP_a_or_b_RP(self):
self.assertEqual(self.parser.parse('aa(a|b)'), 'aa+ab|+')
def setUp(self): self.parser = REParser(RPNStringEmitter())
class TestThompson(unittest.TestCase):
def setUp(self):
self.parser = REParser(Thompson())
def test_Empty(self):
nfa = self.parser.parse('')
self.assert_(set(nfa.states[nfa.initial]['']) &set(nfa.finals))
def test_a(self):
nfa = self.parser.parse('a')
self.assert_(set(nfa.states[nfa.initial]['a']) & set(nfa.finals))
def test_a_cat_b(self):
nfa = self.parser.parse('ab')
before_b = nfa.states[nfa.initial]['a']
self.assert_(before_b)
self.assertEqual(len(before_b), 1)
b = before_b[0]
print nfa.finals
self.assert_(set(nfa.states[b]['b']) & set(nfa.finals))
def test_a_or_b(self):
nfa = self.parser.parse('a|b')
for s in nfa.states[nfa.initial]['']:
if 'a' in nfa.states[s]:
an = nfa.states[s]['a']
if 'b' in nfa.states[s]:
bn = nfa.states[s]['b']
ax = set()
print nfa.states
for x in an:
print nfa.states[x]
ax |= set(nfa.states[x][''])
bx = set()
for x in bn:
bx |= set(nfa.states[x][''])
self.assert_(set(ax) & set(nfa.finals))
self.assert_(set(bx) & set(nfa.finals))
def test_a_zom(self):
nfa = self.parser.parse('a*')
self.assert_(set(nfa.states[nfa.initial]['']) & set(nfa.finals))
for s in nfa.states[nfa.initial]['']:
if s not in nfa.finals:
break
Nsi = s
xs = nfa.states[Nsi]['a']
self.assertEqual(len(xs), 1)
Nsf = xs[0]
for s in nfa.states[Nsf]['']:
self.assert_(s in nfa.finals or Nsi == s)
def test_LP_a_or_b_RP_c(self):
nfa = self.parser.parse('(a|b)c')
print 'b -> '
self.assertFalse(nfa.feed('b'))
print 'bc -> '
self.assert_(nfa.feed('bc'))
def test_LP_a_or_b_RP_c_2(self):
nfa = self.parser.parse('(a|b)c')
print 'a -> '
self.assertFalse(nfa.feed('a'))
print 'ac -> '
self.assert_(nfa.feed('ac'))
def setUp(self): self.parser = REParser(Thompson())
b = self.pop()
a = self.pop()
ab = NFA.build_cat(a, b)
self.push(ab)
def ZOM(self, Ns):
a = self.pop()
azom = NFA.build_zom(a)
self.push(azom)
def LP(self, t):
pass
def RP(self, t):
pass
if __name__ == "__main__":
from reparser import REParser
parser = REParser(Thompson())
nfa = parser.parse('(a|b)*abb')
print nfa.states
print 'abb ==>', nfa.feed('abb')
print '--'
print 'babb ==>', nfa.feed('babb')
print '--'
print 'bbabb ==>', nfa.feed('bbabb')
