def test_addThreeRemoveTwoInArray(self):
gr = Grammar()
self.assertEqual(gr.add_nonterm([TempClass, Second, Third]),
[TempClass, Second, Third])
self.assertEqual(gr.nonterms_count(), 3)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertEqual(gr.nonterm(TempClass), TempClass)
self.assertIsNotNone(gr.get_nonterm(Second))
self.assertIsNotNone(gr.nonterm(Second))
self.assertEqual(gr.nonterm(Second), Second)
self.assertIsNotNone(gr.get_nonterm(Third))
self.assertIsNotNone(gr.nonterm(Third))
self.assertEqual(gr.nonterm(Third), Third)
self.assertEqual(gr.remove_nonterm([Third, TempClass]),
[Third, TempClass])
self.assertEqual(gr.nonterms_count(), 1)
self.assertTrue(gr.have_nonterm(Second))
self.assertFalse(gr.have_nonterm(TempClass))
self.assertFalse(gr.have_nonterm(Third))
self.assertEqual(gr.add_nonterm(Third), [Third])
self.assertEqual(gr.nonterms_count(), 2)
self.assertIsNotNone(gr.nonterm(Second))
self.assertEqual(gr.nonterm(Second), Second)
self.assertIsNotNone(gr.get_nonterm(Second))
self.assertIsNotNone(gr.nonterm(Third))
self.assertEqual(gr.nonterm(Third), Third)
self.assertIsNotNone(gr.get_nonterm(Third))
def test_shouldNotSetStartSymbol(self):
g = Grammar(nonterminals=[A, B])
self.assertFalse(g.start_isSet())
with self.assertRaises(NotNonterminalException):
g.start_set('asdf')
self.assertFalse(g.start_isSet())
self.assertFalse(g.start_is('asdf'))
def test_addThreeInTuple(self):
gr = Grammar(terminals=('A', 'B', 'C'))
self.assertTrue(gr.have_term('A'))
self.assertTrue(gr.have_term('B'))
self.assertTrue(gr.have_term('C'))
self.assertTrue(gr.have_term(['A', 'B', 'C']))
self.assertFalse(gr.have_term('D'))
def test_shouldNotSetStartSymbol(self):
g = Grammar(nonterminals=[A])
self.assertFalse(g.start_isSet())
with self.assertRaises(NonterminalDoesNotExistsException):
g.start_set(B)
self.assertFalse(g.start_isSet())
self.assertFalse(g.start_is(B))
def test_shouldAddIntoGrammar(self):
class Tmp1(_R):
rule = ([NFirst], ['a', 0])
g = Grammar(terminals=['a', 0], nonterminals=[NFirst], rules=[Tmp1])
g.add_rule(Tmp1)
self.assertEqual(g.get_rule(Tmp1), Tmp1)
def test_addThreeRemoveTwoInArray(self):
gr = Grammar()
add = gr.add_term([0, 'asdf', TempClass])
self.assertEqual(add[0].s, 0)
self.assertEqual(add[1].s, 'asdf')
self.assertEqual(add[2].s, TempClass)
self.assertEqual(gr.terms_count(), 3)
self.assertIsNotNone(gr.get_term(0))
self.assertIsNotNone(gr.term(0))
self.assertTrue(isinstance(gr.term(0), Terminal))
self.assertEqual(gr.term(0).s, 0)
self.assertIsNotNone(gr.get_term('asdf'))
self.assertIsNotNone(gr.term('asdf'))
self.assertTrue(isinstance(gr.term('asdf'), Terminal))
self.assertEqual(gr.term('asdf').s, 'asdf')
self.assertIsNotNone(gr.get_term(TempClass))
self.assertIsNotNone(gr.term(TempClass))
self.assertTrue(isinstance(gr.term(TempClass), Terminal))
self.assertEqual(gr.term(TempClass).s, TempClass)
rem = gr.remove_term([0, 'asdf'])
self.assertEqual(rem[0].s, 0)
self.assertEqual(rem[1].s, 'asdf')
self.assertEqual(gr.terms_count(), 1)
self.assertTrue(gr.have_term(TempClass))
self.assertFalse(gr.have_term(0))
self.assertFalse(gr.have_term('asdf'))
self.assertEqual(gr.add_term(0)[0].s, 0)
self.assertEqual(gr.terms_count(), 2)
self.assertTrue(gr.have_term(TempClass))
self.assertTrue(gr.have_term(0))
self.assertFalse(gr.have_term('asdf'))
def setUp(self):
self.g = Grammar(
terminals=[
0, 1, 2, 'a', 'b', 'c', TFirst, TSecond, TThird, TInstFirst,
TInstSecond, TInstThird
],
nonterminals=[NFirst, NSecond, NThird, NFourth, NFifth])
def test_correctAddTwo(self):
gr = Grammar()
self.assertEqual(gr.terms_count(), 0)
self.assertIsNone(gr.get_term(0))
self.assertIsNone(gr.term(0))
self.assertIsNone(gr.get_term('asdf'))
self.assertIsNone(gr.term('asdf'))
gr.add_term(0)
self.assertEqual(gr.terms_count(), 1)
self.assertIsNotNone(gr.get_term(0))
self.assertIsNotNone(gr.term(0))
self.assertTrue(isinstance(gr.term(0), Terminal))
self.assertEqual(gr.term(0).s, 0)
self.assertIsNone(gr.get_term('asdf'))
self.assertIsNone(gr.term('asdf'))
gr.add_term('asdf')
self.assertEqual(gr.terms_count(), 2)
self.assertIsNotNone(gr.get_term(0))
self.assertIsNotNone(gr.term(0))
self.assertTrue(isinstance(gr.term(0), Terminal))
self.assertEqual(gr.term(0).s, 0)
self.assertIsNotNone(gr.get_term('asdf'))
self.assertIsNotNone(gr.term('asdf'))
self.assertTrue(isinstance(gr.term('asdf'), Terminal))
self.assertEqual(gr.term('asdf').s, 'asdf')
def test_addTwoRemoveOneAndAddThird(self):
gr = Grammar()
self.assertEqual(gr.add_nonterm(TempClass), [TempClass])
self.assertEqual(gr.add_nonterm(Second), [Second])
self.assertEqual(gr.nonterms_count(), 2)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertEqual(gr.get_nonterm(TempClass), TempClass)
self.assertIsNotNone(gr.get_nonterm(Second))
self.assertIsNotNone(gr.nonterm(Second))
self.assertEqual(gr.get_nonterm(Second), Second)
self.assertEqual(gr.remove_nonterm(Second), [Second])
self.assertEqual(gr.nonterms_count(), 1)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertEqual(gr.nonterm(TempClass), TempClass)
self.assertIsNone(gr.get_nonterm(Second))
self.assertEqual(gr.add_nonterm(Third), [Third])
self.assertEqual(gr.nonterms_count(), 2)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertEqual(gr.get_nonterm(TempClass), TempClass)
self.assertFalse(gr.have_nonterm(Second))
self.assertIsNone(gr.nonterm(Second))
self.assertIsNotNone(gr.get_nonterm(Third))
self.assertIsNotNone(gr.nonterm(Third))
self.assertEqual(gr.get_nonterm(Third), Third)
def test_addThreeInString(self):
gr = Grammar(terminals='ABC')
self.assertTrue(gr.have_term('A'))
self.assertTrue(gr.have_term('B'))
self.assertTrue(gr.have_term('C'))
self.assertTrue(gr.have_term(('A', 'B', 'C')))
self.assertFalse(gr.have_term('D'))
def test_equalGetTermAndTermMethods(self):
gr = Grammar()
ins = TempClass()
gr.add_term(ins)
self.assertEqual(gr.terms_count(), 1)
self.assertEqual(gr.get_term(ins).s, ins)
self.assertEqual(gr.term(ins).s, ins)
self.assertEqual(gr.term(ins).s, gr.get_term(ins).s)
def test_getTermTuple(self):
gr = Grammar()
gr.add_term([TempClass, 0, 'asdf'])
g = gr.get_term((0, 'asdf'))
for i in g:
self.assertTrue(i.s in [TempClass, 0, 'asdf'])
self.assertEqual(g[0].s, 0)
self.assertEqual(g[1].s, 'asdf')
def test_oldStartSymbolShouldStaySame(self):
g = Grammar(nonterminals=[A, B], start_symbol=A)
self.assertTrue(g.start_isSet())
with self.assertRaises(NotNonterminalException):
g.start_set('asdf')
self.assertTrue(g.start_isSet())
self.assertTrue(g.start_is(A))
self.assertEqual(g.start_get(), A)
def test_removeTwoInTuple(self):
gr = Grammar()
gr.add_nonterm([TempClass, Second, Third])
self.assertEqual(gr.nonterms_count(), 3)
gr.remove_nonterm((Second, TempClass))
self.assertEqual(gr.nonterms_count(), 1)
self.assertFalse(gr.have_nonterm(TempClass))
self.assertTrue(gr.have_nonterm(Third))
self.assertFalse(gr.have_nonterm(Second))
def test_removeAllWithoutParam(self):
gr = Grammar()
gr.add_nonterm([TempClass, Second, Third])
self.assertEqual(gr.nonterms_count(), 3)
gr.remove_nonterm()
self.assertEqual(gr.nonterms_count(), 0)
self.assertFalse(gr.have_nonterm(TempClass))
self.assertFalse(gr.have_nonterm(Second))
self.assertFalse(gr.have_nonterm(Third))
def test_removeTwoInTuple(self):
gr = Grammar()
gr.add_term([0, 'asdf', TempClass])
self.assertEqual(gr.terms_count(), 3)
gr.remove_term((0, 'asdf'))
self.assertEqual(gr.terms_count(), 1)
self.assertTrue(gr.have_term(TempClass))
self.assertFalse(gr.have_term('asdf'))
self.assertFalse(gr.have_term(0))
def test_removeAllWithoutParam(self):
gr = Grammar()
gr.add_term([0, 'asdf', TempClass])
self.assertEqual(gr.terms_count(), 3)
gr.remove_term()
self.assertEqual(gr.terms_count(), 0)
self.assertFalse(gr.have_term(TempClass))
self.assertFalse(gr.have_term('asdf'))
self.assertFalse(gr.have_term(0))
def test_addInArray(self):
gr = Grammar()
gr.add_nonterm([Second, TempClass])
self.assertEqual(gr.nonterms_count(), 2)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertEqual(gr.nonterm(TempClass), TempClass)
self.assertIsNotNone(gr.get_nonterm(Second))
self.assertIsNotNone(gr.nonterm(Second))
self.assertEqual(gr.nonterm(Second), Second)
self.assertIsNone(gr.get_nonterm(Third))
self.assertIsNone(gr.nonterm(Third))
def test_correctAddOne(self):
gr = Grammar()
self.assertEqual(gr.terms_count(), 0)
self.assertFalse(gr.have_nonterm(TempClass))
self.assertIsNone(gr.get_nonterm(TempClass))
self.assertIsNone(gr.nonterm(TempClass))
gr.add_nonterm(TempClass)
self.assertEqual(gr.nonterms_count(), 1)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertTrue(issubclass(gr.nonterm(TempClass), TempClass))
self.assertEqual(hash(gr.nonterm(TempClass)), hash(TempClass))
def test_correctAddOne(self):
gr = Grammar()
self.assertEqual(gr.terms_count(), 0)
self.assertFalse(gr.have_term(0))
self.assertIsNone(gr.get_term(0))
self.assertIsNone(gr.term(0))
gr.add_term(0)
self.assertEqual(gr.terms_count(), 1)
self.assertIsNotNone(gr.get_term(0))
self.assertIsNotNone(gr.term(0))
self.assertTrue(isinstance(gr.term(0), Terminal))
self.assertEqual(gr.term(0).symbol(), 0)
def test_addThreeOneDelete(self):
gr = Grammar(terminals=('A', 'B', 'C'))
self.assertTrue(gr.have_term('A'))
self.assertTrue(gr.have_term('B'))
self.assertTrue(gr.have_term('C'))
self.assertTrue(gr.have_term(['A', 'B', 'C']))
self.assertFalse(gr.have_term('D'))
gr.remove_term('B')
self.assertTrue(gr.have_term('A'))
self.assertFalse(gr.have_term('B'))
self.assertTrue(gr.have_term('C'))
self.assertTrue(gr.have_term(['A', 'C']))
self.assertFalse(gr.have_term('D'))
def test_oneSeparateTwoTuple(self):
gr = Grammar()
gr.add_nonterm(TempClass)
self.assertEqual(gr.nonterms_count(), 1)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertEqual(gr.nonterm(TempClass), TempClass)
gr.add_nonterm((Second, Third))
self.assertEqual(gr.nonterms_count(), 3)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertIsNotNone(gr.get_nonterm(Second))
self.assertIsNotNone(gr.nonterm(Second))
self.assertIsNotNone(gr.get_nonterm(Third))
self.assertIsNotNone(gr.nonterm(Third))
def test_addInArray(self):
gr = Grammar()
gr.add_term([0, 'asdf', TempClass])
self.assertEqual(gr.terms_count(), 3)
self.assertIsNotNone(gr.get_term(0))
self.assertIsNotNone(gr.term(0))
self.assertTrue(isinstance(gr.term(0), Terminal))
self.assertEqual(gr.term(0).s, 0)
self.assertIsNotNone(gr.get_term('asdf'))
self.assertIsNotNone(gr.term('asdf'))
self.assertTrue(isinstance(gr.term('asdf'), Terminal))
self.assertEqual(gr.term('asdf').s, 'asdf')
self.assertIsNotNone(gr.get_term(TempClass))
self.assertIsNotNone(gr.term(TempClass))
self.assertTrue(isinstance(gr.term(TempClass), Terminal))
self.assertEqual(gr.term(TempClass).s, TempClass)
def test_add_remove_add_one(self):
gr = Grammar()
self.assertEqual(gr.nonterms_count(), 0)
self.assertFalse(gr.have_nonterm(TempClass))
self.assertIsNone(gr.get_nonterm(TempClass))
self.assertIsNone(gr.nonterm(TempClass))
self.assertEqual(gr.add_nonterm(TempClass), [TempClass])
self.assertEqual(gr.nonterms_count(), 1)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertEqual(gr.nonterm(TempClass), TempClass)
self.assertEqual(gr.remove_nonterm(TempClass), [TempClass])
self.assertEqual(gr.nonterms_count(), 0)
self.assertFalse(gr.have_nonterm(TempClass))
self.assertIsNone(gr.get_nonterm(TempClass))
self.assertIsNone(gr.nonterm(TempClass))
def test_shouldProcessInConstructor(self):
class Tmp1(Rule):
rules = [([NFirst], [NSecond, 0]), ([NThird], [0, 1]),
([NSecond], [NSecond, 'a'])]
self.g = Grammar(
terminals=[
0, 1, 2, 'a', 'b', 'c', TFirst, TSecond, TThird, TInstFirst,
TInstSecond, TInstThird
],
nonterminals=[NFirst, NSecond, NThird, NFourth, NFifth],
rules=[Tmp1])
r = self.g.get_rule(Tmp1)
self.assertIsInstance(r, list)
self.assertEqual(len(r), 3)
for rule in r:
self.assertIn(rule.rule, Tmp1.rules)
def test_oneSeparateTwoTuple(self):
gr = Grammar()
gr.add_term(0)
self.assertEqual(gr.terms_count(), 1)
self.assertIsNotNone(gr.get_term(0))
self.assertIsNotNone(gr.term(0))
self.assertTrue(isinstance(gr.term(0), Terminal))
self.assertEqual(gr.term(0).s, 0)
gr.add_term(('asdf', TempClass))
self.assertEqual(gr.terms_count(), 3)
self.assertIsNotNone(gr.get_term(0))
self.assertIsNotNone(gr.term(0))
self.assertTrue(isinstance(gr.term(0), Terminal))
self.assertEqual(gr.term(0).s, 0)
self.assertIsNotNone(gr.get_term('asdf'))
self.assertIsNotNone(gr.term('asdf'))
self.assertTrue(isinstance(gr.term('asdf'), Terminal))
self.assertEqual(gr.term('asdf').s, 'asdf')
self.assertIsNotNone(gr.get_term(TempClass))
self.assertIsNotNone(gr.term(TempClass))
self.assertTrue(isinstance(gr.term(TempClass), Terminal))
self.assertEqual(gr.term(TempClass).s, TempClass)
def test_addTwoRemoveOneAndAddThird(self):
gr = Grammar()
self.assertEqual(gr.add_term(0)[0].s, 0)
self.assertEqual(gr.add_term('asdf')[0].s, 'asdf')
self.assertEqual(gr.terms_count(), 2)
self.assertIsNotNone(gr.get_term(0))
self.assertIsNotNone(gr.term(0))
self.assertTrue(isinstance(gr.term(0), Terminal))
self.assertEqual(gr.term(0).s, 0)
self.assertIsNotNone(gr.get_term('asdf'))
self.assertIsNotNone(gr.term('asdf'))
self.assertTrue(isinstance(gr.term('asdf'), Terminal))
self.assertEqual(gr.term('asdf').s, 'asdf')
self.assertEqual(gr.remove_term('asdf')[0].s, 'asdf')
self.assertEqual(gr.terms_count(), 1)
self.assertIsNotNone(gr.get_term(0))
self.assertIsNotNone(gr.term(0))
self.assertTrue(isinstance(gr.term(0), Terminal))
self.assertEqual(gr.term(0).s, 0)
self.assertEqual(gr.add_term(TempClass)[0].s, TempClass)
self.assertEqual(gr.terms_count(), 2)
self.assertTrue(gr.have_term(0))
self.assertFalse(gr.have_term('asdf'))
self.assertTrue(gr.have_term(TempClass))
def test_correctAddTwo(self):
gr = Grammar()
self.assertEqual(gr.nonterms_count(), 0)
self.assertIsNone(gr.get_nonterm(TempClass))
self.assertIsNone(gr.nonterm(TempClass))
self.assertIsNone(gr.get_nonterm(Second))
self.assertIsNone(gr.nonterm(Second))
gr.add_nonterm(TempClass)
self.assertEqual(gr.nonterms_count(), 1)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertTrue(issubclass(gr.nonterm(TempClass), Nonterminal))
self.assertEqual(gr.nonterm(TempClass), TempClass)
self.assertIsNone(gr.get_nonterm(Second))
self.assertIsNone(gr.nonterm(Second))
gr.add_nonterm(Second)
self.assertEqual(gr.nonterms_count(), 2)
self.assertIsNotNone(gr.get_nonterm(TempClass))
self.assertIsNotNone(gr.nonterm(TempClass))
self.assertTrue(issubclass(gr.nonterm(TempClass), Nonterminal))
self.assertEqual(gr.nonterm(TempClass), TempClass)
self.assertIsNotNone(gr.nonterm(Second))
self.assertTrue(issubclass(gr.nonterm(Second), Nonterminal))
self.assertEqual(gr.nonterm(Second), Second)
def test_shouldNotAddOneInvalidNonterminal(self):
with self.assertRaises(NotNonterminalException):
Grammar(nonterminals=[A, B, 1])
def test_shouldAddMoreNonterminals(self):
g = Grammar(nonterminals=[A, B, C])
self.assertTrue(g.have_nonterm(A))
self.assertTrue(g.have_nonterm([A, B, C]))
self.assertFalse(g.have_nonterm(D))
