Python Grammar.add_nonterm Examples

Example #1

File: NonterminalAddRemoveMixedTest.py Project: iCodeIN/grammpy

 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)

Example #2

File: NonterminalAddRemoveMixedTest.py Project: iCodeIN/grammpy

 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))

Example #3

File: NonterminalRemoveTest.py Project: iCodeIN/grammpy

 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))

Example #4

File: NonterminalRemoveTest.py Project: iCodeIN/grammpy

 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))

Example #5

 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))

Example #6

 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))

Example #7

 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))

Example #8

 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)

Example #9

File: NonterminalAddRemoveMixedTest.py Project: iCodeIN/grammpy

 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))

Example #10

File: NonterminalHaveTest.py Project: iCodeIN/grammpy

 def test_haveNontermClass(self):
     gr = Grammar()
     gr.add_nonterm(TempClass)
     self.assertTrue(gr.have_nonterm(TempClass))

Example #11

File: IterationTest.py Project: iCodeIN/grammpy

 def setUp(self):
     g = Grammar()
     g.add_term([0, 1, 2, 'a', 'b', 'c'])
     g.add_nonterm([NFirst, NSecond, NThird, NFourth])
     self.g = g

Example #12

File: NonterminalIterationTest.py Project: iCodeIN/grammpy

 def test_ThreeNonterminalGetNonterm(self):
     gr = Grammar()
     gr.add_nonterm([TempClass, Second, Third])
     s = gr.get_nonterm()
     for i in [Second, Third, TempClass]:
         self.assertIn(i, s)

Example #13

File: NonterminalIterationTest.py Project: iCodeIN/grammpy

 def test_oneNonterminalGetNonterm(self):
     gr = Grammar()
     gr.add_nonterm(TempClass)
     for i in gr.get_nonterm():
         self.assertEqual(i, TempClass)

Example #14

 def test_invalidGetAfterCorrectAdd(self):
     gr = Grammar()
     gr.add_nonterm(TempClass)
     with self.assertRaises(NotNonterminalException):
         gr.get_nonterm("asdf")

Example #15

 def test_invalidAddInArray(self):
     gr = Grammar()
     with self.assertRaises(NotNonterminalException):
         gr.add_nonterm([TempClass, "asdf"])

Example #16

 def test_invalidAddString(self):
     gr = Grammar()
     with self.assertRaises(NotNonterminalException):
         gr.add_nonterm("string")

Example #17

 def test_invalidAddNumber(self):
     gr = Grammar()
     with self.assertRaises(NotNonterminalException):
         gr.add_nonterm(0)