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