Python Grammar.add_termの例

コード例 #1

ファイル: TerminalAddRemoveMixedTest.py プロジェクト: iCodeIN/grammpy

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

コード例 #2

ファイル: TerminalAddingTest.py プロジェクト: iCodeIN/grammpy

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

コード例 #3

ファイル: TerminalAddingTest.py プロジェクト: iCodeIN/grammpy

 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)

コード例 #4

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

コード例 #5

ファイル: TerminalRemoveTest.py プロジェクト: iCodeIN/grammpy

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

コード例 #6

ファイル: TerminalRemoveTest.py プロジェクト: iCodeIN/grammpy

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

コード例 #7

ファイル: TerminalAddingTest.py プロジェクト: iCodeIN/grammpy

 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)

コード例 #8

ファイル: TerminalAddingTest.py プロジェクト: iCodeIN/grammpy

 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)

コード例 #9

ファイル: TerminalAddingTest.py プロジェクト: iCodeIN/grammpy

 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)

コード例 #10

ファイル: TerminalAddRemoveMixedTest.py プロジェクト: iCodeIN/grammpy

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

コード例 #11

 def test_haveTermTuple(self):
     gr = Grammar()
     gr.add_term([TempClass, 0, 'asdf'])
     self.assertTrue(gr.have_term((0, 'asdf')))

コード例 #12

ファイル: IterationTest.py プロジェクト: 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

コード例 #13

 def test_dontHaveTermTuple(self):
     gr = Grammar()
     gr.add_term([TempClass, 0, 'asdf'])
     self.assertFalse(gr.have_term((TempClass, 'a')))

コード例 #14

 def test_haveTermArray(self):
     gr = Grammar()
     gr.add_term([TempClass, 0, 'asdf'])
     self.assertTrue(gr.have_term([0, 'asdf']))

コード例 #15

ファイル: NonterminalHaveTest.py プロジェクト: iCodeIN/grammpy

 def test_haveNontermTuple(self):
     gr = Grammar()
     gr.add_term([TempClass, Second, Third])
     self.assertTrue(gr.have_term((Third, TempClass)))

コード例 #16

ファイル: TerminalIterationTest.py プロジェクト: iCodeIN/grammpy

 def test_ThreeTerminalGetTerm(self):
     gr = Grammar()
     gr.add_term([0, 'a', TempClass])
     s = set(term.s for term in gr.get_term())
     for i in [0, 'a', TempClass]:
         self.assertIn(i, s)

コード例 #17

ファイル: TerminalIterationTest.py プロジェクト: iCodeIN/grammpy

 def test_oneTerminalGetTerm(self):
     gr = Grammar()
     gr.add_term('a')
     for i in gr.get_term():
         self.assertEqual(i.s, 'a')

コード例 #18

ファイル: TerminalIterationTest.py プロジェクト: iCodeIN/grammpy

 def test_oneTerminalTerms(self):
     gr = Grammar()
     gr.add_term('a')
     for i in gr.terms():
         self.assertEqual(i.s, 'a')

コード例 #19

 def test_rawTermMethod(self):
     gr = Grammar()
     gr.add_term([TempClass, 'a', 0])
     self.assertEqual(gr.term(['a'])[0].s, 'a')
     self.assertIsInstance(gr.term([0])[0], Terminal)
     self.assertIsNone(gr.term(['asdf'])[0])

コード例 #20

ファイル: TerminalIterationTest.py プロジェクト: iCodeIN/grammpy

 def test_ThreeTerminalTerms(self):
     gr = Grammar()
     gr.add_term([0, 'a', TempClass])
     s = set(term.s for term in gr.terms())
     for i in [0, 'a', TempClass]:
         self.assertTrue(i in s)

コード例 #21

 def test_getTermClass(self):
     gr = Grammar()
     gr.add_term(TempClass)
     self.assertEqual(gr.get_term(TempClass).s, TempClass)

コード例 #22

ファイル: NonterminalHaveTest.py プロジェクト: iCodeIN/grammpy

 def test_haveNontermArray(self):
     gr = Grammar()
     gr.add_term([TempClass, Second, Third])
     self.assertTrue(gr.have_term([Second, TempClass]))

コード例 #23

 def test_dontGetTermTuple(self):
     gr = Grammar()
     gr.add_term([TempClass, 0, 'asdf'])
     g = gr.get_term((TempClass, 'a'))
     self.assertEqual(g[0].s, TempClass)
     self.assertIsNone(g[1])

コード例 #24

ファイル: NonterminalHaveTest.py プロジェクト: iCodeIN/grammpy

 def test_dontHaveNontermTuple(self):
     gr = Grammar()
     gr.add_term([TempClass, Second])
     self.assertFalse(gr.have_term((TempClass, Third)))

コード例 #25

 def test_haveTermClass(self):
     gr = Grammar()
     gr.add_term(TempClass)
     self.assertTrue(gr.have_term(TempClass))