def test_reachablesInvalid(self):
g = Grammar(terminals=[0, 1, 2],
nonterminals=[S, A, B, C],
rules=[Rules],
start_symbol=S)
res = ContextFree.find_nonterminals_reachable_by_unit_rules(g)
self.assertEqual(res.reachables(D), [])
self.assertEqual(res.reachables(E), [])
def test_pathRulesInvalid(self):
g = Grammar(terminals=[0, 1, 2],
nonterminals=[S, A, B, C],
rules=[Rules],
start_symbol=S)
res = ContextFree.find_nonterminals_reachable_by_unit_rules(g)
self.assertIsNone(res.path_rules(A, D))
self.assertIsNone(res.path_rules(D, S))
self.assertIsNone(res.path_rules(D, S))
self.assertIsNone(res.path_rules(E, D))
def test_reachInvalid(self):
g = Grammar(terminals=[0, 1, 2],
nonterminals=[S, A, B, C],
rules=[Rules],
start_symbol=S)
res = ContextFree.find_nonterminals_reachable_by_unit_rules(g)
self.assertFalse(res.reach(D, S))
self.assertFalse(res.reach(S, D))
self.assertFalse(res.reach(D, D))
self.assertFalse(res.reach(D, E))
def test_simpleTest(self):
g = Grammar(terminals=[0, 1, 2],
nonterminals=[S, A, B, C],
rules=[Rules],
start_symbol=S)
res = ContextFree.find_nonterminals_reachable_by_unit_rules(g)
# From S
self.assertTrue(res.reach(S, S))
self.assertTrue(res.reach(S, A))
self.assertTrue(res.reach(S, B))
self.assertTrue(res.reach(S, C))
# From A
self.assertFalse(res.reach(B, S))
self.assertTrue(res.reach(B, A))
self.assertTrue(res.reach(B, B))
self.assertTrue(res.reach(B, C))
# From B
self.assertFalse(res.reach(B, S))
self.assertTrue(res.reach(B, A))
self.assertTrue(res.reach(B, B))
self.assertTrue(res.reach(B, C))
# From C
self.assertFalse(res.reach(C, S))
self.assertTrue(res.reach(C, A))
self.assertTrue(res.reach(C, B))
self.assertTrue(res.reach(C, C))
# Reachables
self.assertEqual(len(res.reachables(S)), 4)
for n in [S, A, B, C]:
self.assertIn(n, res.reachables(S))
self.assertEqual(len(res.reachables(A)), 3)
for n in [A, B, C]:
self.assertIn(n, res.reachables(A))
self.assertEqual(len(res.reachables(B)), 3)
for n in [A, B, C]:
self.assertIn(n, res.reachables(B))
self.assertEqual(len(res.reachables(C)), 3)
for n in [A, B, C]:
self.assertIn(n, res.reachables(C))
# Rules S
self.assertEqual(res.path_rules(S, S), [])
SARules = res.path_rules(S, A)
self.assertEqual(len(SARules), 1)
self.assertEqual(SARules[0].rule, ([S], [A]))
SBRules = res.path_rules(S, B)
self.assertEqual(len(SBRules), 2)
self.assertEqual(SBRules[0].rule, ([S], [A]))
self.assertEqual(SBRules[1].rule, ([A], [B]))
SCRules = res.path_rules(S, C)
self.assertEqual(len(SCRules), 3)
self.assertEqual(SCRules[0].rule, ([S], [A]))
self.assertEqual(SCRules[1].rule, ([A], [B]))
self.assertEqual(SCRules[2].rule, ([B], [C]))
# Rules A
self.assertEqual(res.path_rules(A, A), [])
ABRules = res.path_rules(A, B)
self.assertEqual(len(ABRules), 1)
self.assertEqual(ABRules[0].rule, ([A], [B]))
ACRules = res.path_rules(A, C)
self.assertEqual(len(ACRules), 2)
self.assertEqual(ACRules[0].rule, ([A], [B]))
self.assertEqual(ACRules[1].rule, ([B], [C]))
# Rules B
self.assertEqual(res.path_rules(B, B), [])
BCRules = res.path_rules(B, C)
self.assertEqual(len(BCRules), 1)
self.assertEqual(BCRules[0].rule, ([B], [C]))
BARules = res.path_rules(B, A)
self.assertEqual(len(BARules), 2)
self.assertEqual(BARules[0].rule, ([B], [C]))
self.assertEqual(BARules[1].rule, ([C], [A]))
# Rules C
self.assertEqual(res.path_rules(C, C), [])
CARules = res.path_rules(C, A)
self.assertEqual(len(CARules), 1)
self.assertEqual(CARules[0].rule, ([C], [A]))
CBRules = res.path_rules(C, B)
self.assertEqual(len(CBRules), 2)
self.assertEqual(CBRules[0].rule, ([C], [A]))
self.assertEqual(CBRules[1].rule, ([A], [B]))
def test_simpleTest(self):
g = Grammar(terminals=[0, 1, 2, 3],
nonterminals=[S, A, B, C, D],
rules=[Rules],
start_symbol=S)
res = ContextFree.find_nonterminals_reachable_by_unit_rules(g)
# From S
self.assertTrue(res.reach(S, S))
self.assertTrue(res.reach(S, A))
self.assertTrue(res.reach(S, B))
self.assertTrue(res.reach(S, C))
self.assertTrue(res.reach(S, D))
# From A
self.assertFalse(res.reach(A, S))
self.assertTrue(res.reach(A, A))
self.assertFalse(res.reach(A, B))
self.assertTrue(res.reach(A, C))
self.assertFalse(res.reach(A, D))
# From B
self.assertFalse(res.reach(B, S))
self.assertFalse(res.reach(B, A))
self.assertTrue(res.reach(B, B))
self.assertFalse(res.reach(B, C))
self.assertTrue(res.reach(B, D))
# From C
self.assertFalse(res.reach(C, S))
self.assertFalse(res.reach(C, A))
self.assertFalse(res.reach(C, B))
self.assertTrue(res.reach(C, C))
self.assertFalse(res.reach(C, D))
# From D
self.assertFalse(res.reach(D, S))
self.assertFalse(res.reach(D, A))
self.assertFalse(res.reach(D, B))
self.assertFalse(res.reach(D, C))
self.assertTrue(res.reach(D, D))
# Reachables
self.assertEqual(len(res.reachables(S)), 5)
for n in [S, A, B, C, D]:
self.assertIn(n, res.reachables(S))
self.assertEqual(len(res.reachables(A)), 2)
for n in [A, C]:
self.assertIn(n, res.reachables(A))
self.assertEqual(len(res.reachables(B)), 2)
for n in [B, D]:
self.assertIn(n, res.reachables(B))
self.assertEqual(len(res.reachables(C)), 1)
for n in [C]:
self.assertIn(n, res.reachables(C))
self.assertEqual(len(res.reachables(D)), 1)
for n in [D]:
self.assertIn(n, res.reachables(D))
# Rules S
self.assertEqual(res.path_rules(S, S), [])
SARules = res.path_rules(S, A)
self.assertEqual(len(SARules), 1)
self.assertEqual(SARules[0].rule, ([S], [A]))
SBRules = res.path_rules(S, B)
self.assertEqual(len(SBRules), 1)
self.assertEqual(SBRules[0].rule, ([S], [B]))
SCRules = res.path_rules(S, C)
self.assertEqual(len(SCRules), 2)
self.assertEqual(SCRules[0].rule, ([S], [A]))
self.assertEqual(SCRules[1].rule, ([A], [C]))
SDRules = res.path_rules(S, D)
self.assertEqual(len(SDRules), 2)
self.assertEqual(SDRules[0].rule, ([S], [B]))
self.assertEqual(SDRules[1].rule, ([B], [D]))
# Rules A
self.assertEqual(res.path_rules(A, A), [])
ACRules = res.path_rules(A, C)
self.assertEqual(len(ACRules), 1)
self.assertEqual(ACRules[0].rule, ([A], [C]))
# Rules B
self.assertEqual(res.path_rules(B, B), [])
BDRules = res.path_rules(B, D)
self.assertEqual(len(BDRules), 1)
self.assertEqual(BDRules[0].rule, ([B], [D]))
# Rules C
self.assertEqual(res.path_rules(C, C), [])
# Rules D
self.assertEqual(res.path_rules(D, D), [])
