def test_shift_all(self):
Sym = self.Sym1
rule = Rule(Sym.HEAD, (Sym.A, Sym.B))
items = (
Item(Rule(Sym.HEAD, (Sym.A,)), 1),
Item(Rule(Sym.HEAD, (Sym.A, Sym.B)), 1),
Item(Rule(Sym.HEAD, (Sym.A, Sym.A)), 1),
)
expect_items = (
Item(Rule(Sym.HEAD, (Sym.A, Sym.A)), 2),
)
self.assertEqual(
Label(expect_items),
shift_all(Label(items), Sym.A))
def test_update_rule_nullable_yes(self):
symbol_data = SymbolData()
rule = Rule(LetterSym.C, (LetterSym.A, LetterSym.D))
symbol_data[LetterSym.A].nullable = True
symbol_data[LetterSym.D].nullable = True
self.assertTrue(update_rule_nullable(rule, symbol_data))
self.assertTrue(symbol_data[LetterSym.C].nullable)
def test_fill_state_graph(self):
class Sym(SymbolEnum):
START = ('START', False)
MIDDLE = ('MIDDLE', True)
END = ('END', None)
Rules = (Rule(Sym.START, (Sym.MIDDLE, Sym.MIDDLE)),)
graph = StateGraph()
with patch.object(graph, 'iter_state_ids', return_value=range(3)):
with patch('slr1.build_transition') as mock_bt:
fill_state_graph(graph, Sym, Rules)
self.assertEqual(9, mock_bt.call_count)
self.assertEqual(
mock_bt.call_args_list, [
call(graph, Rules, 0, Sym.START),
call(graph, Rules, 0, Sym.MIDDLE),
call(graph, Rules, 0, Sym.END),
call(graph, Rules, 1, Sym.START),
call(graph, Rules, 1, Sym.MIDDLE),
call(graph, Rules, 1, Sym.END),
call(graph, Rules, 2, Sym.START),
call(graph, Rules, 2, Sym.MIDDLE),
call(graph, Rules, 2, Sym.END),
])
def test_rule_first_set(self):
symbol_data = SymbolData()
rule = Rule(LetterSym.B, (LetterSym.C, LetterSym.A, LetterSym.D))
symbol_data[LetterSym.C].nullable = True
symbol_data[LetterSym.C].first_set = {'ceta'}
symbol_data[LetterSym.A].first_set = {'alpha'}
symbol_data[LetterSym.D].first_set = {'delta'}
self.assertEqual({'ceta', 'alpha'},
rule_first_set(rule, symbol_data))
def do_not_test_tiny_grammer(self):
class TinySym(SymbolEnum):
START = ('START', False)
integer = ('integer', True)
_EOF = ('_EOF', None)
table = generate_action_table(
TinySym, TinySym.START,
[Rule(TinySym.START, (TinySym.integer,))],
)
def test_add_reduce_operations(self):
Symbols = self.Symbols
rule = Rule(Symbols.START, (Symbols.MIDDLE,))
table = ActionTable()
graph = StateGraph()
graph._states.append((Label.from_rule(rule, 1), {}))
data = SymbolData()
data[Symbols.START].follow_set.add(Symbols.END)
add_reduce_operations(table, graph, data)
self.assertEqual(Action('reduce', rule), table[0, Symbols.END])
def test_new_rule_listing(self):
class Enum1(SymbolEnum):
N = ('N', False)
T = ('T', True)
class Rules(RuleListing, symbol_type=Enum1):
TWO = 'N', ['T', 'T']
self.assertIsInstance(Rules.TWO, Rule)
self.assertEqual(Rule(Enum1.N, (Enum1.T, Enum1.T)), Rules.TWO)
def test_rule_follow_set(self):
symbol_data = SymbolData()
rule = Rule(LetterSym.B, (LetterSym.A, LetterSym.C, LetterSym.D))
symbol_data[LetterSym.C].nullable = True
symbol_data[LetterSym.C].first_set = {'ceta'}
symbol_data[LetterSym.A].first_set = {'alpha'}
symbol_data[LetterSym.D].first_set = {'delta'}
symbol_data[LetterSym.B].follow_set = {'beta'}
self.assertEqual(defaultdict(set, {
LetterSym.A: {'ceta', 'delta'},
LetterSym.C: {'delta'},
LetterSym.D: {'beta'},
}),
rule_follow_set(rule, symbol_data))
def test_fill_kernal_label(self):
Sym = self.Sym1
rules = (
Rule(Sym.HEAD, (Sym.A, Sym.B)),
Rule(Sym.A, (Sym.A, Sym.B)),
Rule(Sym.B, (Sym.X, Sym.Y)),
Rule(Sym.X, (Sym.x,)),
Rule(Sym.Y, (Sym.y, Sym.y)),
Rule(Sym.B, ()),
)
items = (
Item(Rule(Sym.HEAD, (Sym.A, Sym.B)), 1),
Item(Rule(Sym.HEAD, (Sym.A, Sym.c)), 1),
)
expect_item = (
Item(Rule(Sym.HEAD, (Sym.A, Sym.c)), 1),
Item(rules[0], 1),
Item(rules[2]),
Item(rules[3]),
Item(rules[5]),
)
self.assertEqual(
Label(expect_item), fill_kernal_label(rules, Label(items)))
def make_imaginary_rule(symbols, starting_symbol):
eof = get_eof_symbol(symbols)
return Rule(eof, (starting_symbol, eof))
def test_update_rule_nullable_empty(self):
symbol_data = SymbolData()
empty_rule = Rule(LetterSym.B, ())
self.assertTrue(update_rule_nullable(empty_rule, symbol_data))
self.assertTrue(symbol_data[LetterSym.B].nullable)
def test_new_label(self):
rule = Rule('S', ('4', '3'))
label = Label([Item(rule), Item(rule, 1)])
def test_item_next_item(self):
rule = Rule('S', ('4', '3'))
item = Item(rule)
self.assertEqual(Item(rule, 1), item.next_item())
def test_repr_item(self):
rule = Rule('S', ('4', '3'))
item = Item(rule, 1)
self.assertEqual(
"Item(rule=Rule(head='S', children=('4', '3')), pos=1)",
repr(item))
def small_label(self, head, children, place):
return Label([Item(Rule(head, children), place)])
def test_make_imaginary_rule(self):
Simple = self.StartEnd
self.assertEqual(Rule(Simple.END, (Simple.START, Simple.END)),
make_imaginary_rule(Simple, Simple.START))
