示例#1
0
    def setUp(self):
        self.arith = grammar.Grammar('S', ('+', '*', '(', ')', 'id'))
        self.result = None

        def get_result(v):
            self.result = v
            return v

        def add(x, y):
            t = x + y
            return t

        def mul(x, y):
            t = x * y
            return t

        self.arith.add_rule('S', ['E', get_result])
        self.arith.add_rule('E', ['E', '+', 'T', add])
        self.arith.add_rule('E', ['T', lambda v: v])
        self.arith.add_rule('T', ['T', '*', 'F', mul])
        self.arith.add_rule('T', ['F', lambda v: v])
        self.arith.add_rule('F', ['(', 'E', ')', lambda v: v])
        self.arith.add_rule('F', ['id', lambda v: v])

        self.action_table, self.goto_table, self.start_state = build_parsing_table(
            self.arith, LR0(self.arith.START, 0, 0))
        self.driver = Driver(self.action_table, self.goto_table,
                             self.start_state)
示例#2
0
    def test_kernel_collection_lalr(self):
        collection = self.kernels_lalr
        propagate_lookaheads(collection)
        self.assertTrue(len(collection) == 7)

        expecteds = [
            (LR0(self.lrvalue.START, 0, 0), [self.lrvalue.EOF]),
            (LR0(self.lrvalue.START, 0, 1), [self.lrvalue.EOF]),
            (LR0('S', 0, 1), [self.lrvalue.EOF]),
            (LR0('C', 0, 1), ['c', 'd', self.lrvalue.EOF]),
            (LR0('C', 1, 1), ['c', 'd', self.lrvalue.EOF]),
            (LR0('S', 0, 2), [self.lrvalue.EOF]),
            (LR0('C', 0, 2), ['c', 'd', self.lrvalue.EOF]),
        ]

        for kernels in collection:
            self.assertTrue(len(kernels) == 1)
            found = False
            count = 0
            for item_lookaheads in expecteds:
                item, lookaheads = item_lookaheads
                if item in kernels:
                    self.assertTrue(
                        set(kernels).pop().lookaheads == set(lookaheads))
                    found = True
                    del expecteds[count]
                    break
                count += 1

            self.assertTrue(found)
示例#3
0
    def setUp(self):
        self.lrvalue = grammar.Grammar('S', ('c', 'd'))

        self.lrvalue.add_rule('S', ['C', 'C'])
        self.lrvalue.add_rule('C', ['c', 'C'])
        self.lrvalue.add_rule('C', ['d'])

        self.StartExtendedSymbol = grammar.Grammar.START

        self.kernels_lalr, self.goto_table = generate_spontaneously_lookaheads(
            self.lrvalue, LR0(self.lrvalue.START, 0, 0),
            UserFriendlyMapping(False))
示例#4
0
    def test_build_tables_of_arithmetic_grammar(self):
        action_table, goto_table, start_set = build_parsing_table(
            self.arith, LR0(self.StartExtendedSymbol, 0, 0))
        states = action_table.keys()

        s5 = None  #Shift to state number 5
        s4 = None  #Shift to state number 4
        count = 0
        for state in states:
            if 'id' in action_table[state]:
                s5 = action_table[state]['id'] if s5 == None else s5
                s4 = action_table[state]['('] if s4 == None else s4
                self.assertTrue(s5 == action_table[state]['id'])
                self.assertTrue(s4 == action_table[state]['('])
                count += 1

        self.assertTrue(count == 4)
        state_5, state_4 = s5._state_to_shift, s4._state_to_shift

        self.assertTrue(action_table[state_5]['+'] == \
              action_table[state_5]['*'] == \
              action_table[state_5][')'] == \
              action_table[state_5][self.arith.EOF])
        self.assertTrue(len(action_table[state_5]) == 4)

        count = 0
        for state in states:
            s = action_table[state]
            try:
                if s['+'] == s['*'] == s[')'] == s[self.arith.EOF]:
                    self.assertTrue(hasattr(s['+'], '_semantic_action'))
                    count += 1
            except:
                pass

        self.assertTrue(count == 4)

        count = 0
        s7 = None
        for state in states:
            s = action_table[state]
            try:
                if s['+'] == s[')'] == s[self.arith.EOF]:
                    count += 1
                    if self.assertTrue(hasattr(s['*'], '_state_to_shift')):
                        s7 = s['*'] if s7 == None else s7
                        self.assertTrue(s7 == s['*'])

            except:
                pass

        self.assertTrue(count == 6)
示例#5
0
    def setUp(self):
        self.arith = grammar.Grammar(
            'S', ('+', '*', '(', ')', 'id', 'var', '=', 'let'))
        self.symbol_table = [dict()]
        self.result = None

        def get_result(x):
            self.result = x
            return x

        def add(x, y):
            t = x + y
            return t

        def mul(x, y):
            t = x * y
            return t

        def set_var(lv, rv):
            self.symbol_table[-1][lv] = rv
            return rv

        def get_var(rv):
            for table in reversed(self.symbol_table):
                if rv in table:
                    return table[rv]

            raise KeyError(rv)

        def push():
            self.symbol_table.append(dict())

        def pop(*others):
            self.symbol_table.pop()

        self.arith.add_rule('S', ['E', get_result])
        self.arith.add_rule('E', ['E', '+', 'T', add])
        self.arith.add_rule('E', ['T', lambda v: v])
        self.arith.add_rule('T', ['T', '*', 'F', mul])
        self.arith.add_rule('T', ['F', lambda v: v])
        self.arith.add_rule('F', ['(', 'E', ')', lambda v: v])
        self.arith.add_rule('F', ['id', lambda v: v])
        self.arith.add_rule('F', ['var', '=', 'E', set_var])
        self.arith.add_rule('F', ['var', get_var])
        self.arith.add_rule('F',
                            ['let', push, '(', 'E', ')', pop, lambda v: v])

        self.action_table, self.goto_table, self.start_state = build_parsing_table(
            self.arith, LR0(self.arith.START, 0, 0))
        self.driver = Driver(self.action_table, self.goto_table,
                             self.start_state)
    def test_equivalence_sets_lalr_and_sets_lr0(self):
        states_lalr = frozenset([
            frozenset([
                LALR(self.StartExtendedSymbol, 0, 0),
            ]),
            frozenset([
                LALR(self.StartExtendedSymbol, 0, 1),
            ]),
            frozenset([
                LALR('S', 0, 1),
            ]),
            frozenset([
                LALR('C', 0, 1),
            ]),
            frozenset([
                LALR('C', 1, 1),
            ]),
            frozenset([
                LALR('S', 0, 2),
            ]),
            frozenset([
                LALR('C', 0, 2),
            ]),
        ])

        states_lr0 = frozenset([
            frozenset([
                LR0(self.StartExtendedSymbol, 0, 0),
            ]),
            frozenset([
                LR0(self.StartExtendedSymbol, 0, 1),
            ]),
            frozenset([
                LR0('S', 0, 1),
            ]),
            frozenset([
                LR0('C', 0, 1),
            ]),
            frozenset([
                LR0('C', 1, 1),
            ]),
            frozenset([
                LR0('S', 0, 2),
            ]),
            frozenset([
                LR0('C', 0, 2),
            ]),
        ])

        self.assertTrue(states_lr0 == states_lalr)
示例#7
0
    def setUp(self):
        self.arith = grammar.Grammar('S', ('(', ')', 'id', 'let'))
        self.symbol_table = [dict()]

        def push(*args):
            pass

        def pop(*args):
            pass

        self.arith.add_rule('S', ['E'])
        self.arith.add_rule('E', ['id'])
        self.arith.add_rule(
            'E', ['let', push, '(', 'E', ')', pop, lambda *args: args])

        self.action_table, self.goto_table, self.start_state = build_parsing_table(
            self.arith, LR0(self.arith.START, 0, 0), disable_mapping=True)
        self.driver = Driver(self.action_table, dict(self.goto_table),
                             self.start_state)
示例#8
0
    def setUp(self):
        syn = syntax.Syntax('input')
        self.result = []

        syn.terminal('NL', None)
        syn.terminal('NUM', None)
        syn.terminal('+', None)
        syn.terminal('-', None)

        syn.repeat(('line', ), 'input')
        syn.choice((('NL', ), ('expr', 'NL', lambda x: self.result.append(x))),
                   'line')
        syn.choice((('NUM', ), ('expr', 'expr', '+', lambda x, y: x + y),
                    ('expr', 'expr', '-', lambda x, y: x - y)), 'expr')

        self.grammar = syn.as_grammar()

        self.start_item = LR0(self.grammar.START, 0, 0)
        self.action_table, self.goto_table, self.start_state = build_parsing_table(
            self.grammar, self.start_item, disable_mapping=True)
        self.driver = Driver(self.action_table, self.goto_table,
                             self.start_state)

        self.kernel_states = [
            frozenset([
                LR0(self.grammar.START, 0, 0),
            ]),
            frozenset([
                LR0(self.grammar.START, 0, 1),
            ]),
            frozenset([
                LR0('input', 0, 1),
                LR0('input', 1, 1),
            ]),
            frozenset([
                LR0('line', 0, 1),
            ]),
            frozenset([
                LR0('line', 1, 1),
                LR0('expr', 1, 1),
                LR0('expr', 2, 1),
            ]),
            frozenset([
                LR0('expr', 0, 1),
            ]),
            frozenset([
                LR0('input', 0, 2),
            ]),
            frozenset([
                LR0('line', 1, 2),
            ]),
            frozenset([
                LR0('expr', 1, 1),
                LR0('expr', 1, 2),
                LR0('expr', 2, 1),
                LR0('expr', 2, 2),
            ]),
            frozenset([
                LR0('expr', 1, 3),
            ]),
            frozenset([
                LR0('expr', 2, 3),
            ])
        ]
示例#9
0
    def test_closures_ofLRValue(self):
        a1 = set([
            LR0(self.StartExtendedSymbol, 0, 0),
            LR0('S', 0, 0),
            LR0('S', 1, 0),
            LR0('R', 0, 0),
            LR0('R', 1, 0),
            LR0('L', 0, 0),
            LR0('L', 1, 0)
        ])

        a2 = set([
            LR0('S', 0, 0),
            LR0('S', 1, 0),
            LR0('R', 0, 0),
            LR0('R', 1, 0),
            LR0('R', 1, 1),
            LR0('L', 0, 0),
            LR0('L', 0, 1),
            LR0('L', 1, 0)
        ])

        self.assertTrue(a1 == closure(
            set([LR0(self.StartExtendedSymbol, 0, 0)]), self.lrvalue))
        self.assertTrue(
            a2 == closure(set([LR0('L', 0, 1), LR0('R', 1, 1)]), self.lrvalue))
示例#10
0
    def test_closures_ofArith(self):
        a1 = set([
            LR0(self.StartExtendedSymbol, 0, 0),
            LR0('E', 0, 0),
            LR0('E', 1, 0),
            LR0('T', 0, 0),
            LR0('T', 1, 0),
            LR0('F', 0, 0),
            LR0('F', 1, 0)
        ])

        a2 = set([
            LR0('F', 0, 1),
            LR0('E', 0, 0),
            LR0('E', 1, 0),
            LR0('T', 0, 0),
            LR0('T', 1, 0),
            LR0('F', 0, 0),
            LR0('F', 1, 0)
        ])

        self.assertTrue(a1 == closure(
            set([LR0(self.StartExtendedSymbol, 0, 0)]), self.arith))
        self.assertTrue(a2 == closure(set([LR0('F', 0, 1)]), self.arith))
示例#11
0
    def test_closures_ofLRValue_with_actions(self):
        a1 = set([
            LR0(self.StartExtendedSymbol, 0, 0),
            LR0('S', 0, 0),
            LR0('S', 1, 0),
            LR0('R', 0, 0),
            LR0('R', 1, 0),
            LR0('L', 0, 0),
            LR0('L', 1, 0)
        ])

        a2 = set([
            LR0(self.lrvalue_with_actions.ACTION_INSIDE % (3, '<lambda>'), 0,
                0),
            LR0('R', 0, 0),
            LR0('R', 1, 0),
            LR0('R', 1, 1),
            LR0('L', 0, 0),
            LR0('L', 0, 1),
            LR0('L', 1, 0)
        ])

        self.assertTrue(
            a1 == closure(set([LR0(self.StartExtendedSymbol, 0, 0)]),
                          self.lrvalue_with_actions))
        self.assertTrue(a2 == closure(set([LR0(
            'L', 0, 1), LR0('R', 1, 1)]), self.lrvalue_with_actions))
示例#12
0
    def test_closures_ofSome(self):
        a1 = set([
            LR0(self.StartExtendedSymbol, 0, 0),
            LR0('S', 0, 0),
            LR0('C', 0, 0),
            LR0('C', 1, 0)
        ])

        a2 = set(
            [LR0('S', 0, 1),
             LR0('C', 0, 0),
             LR0('C', 1, 0),
             LR0('C', 1, 1)])

        self.assertTrue(a1 == closure(
            set([LR0(self.StartExtendedSymbol, 0, 0)]), self.some))
        self.assertTrue(
            a2 == closure(set([LR0('S', 0, 1), LR0('C', 1, 1)]), self.some))
示例#13
0
 def test_build_tables(self):
     action_table, goto_table, start_set = build_parsing_table(
         self.arith, LR0(self.StartExtendedSymbol, 0, 0))
     self.assertTrue(len(action_table) == 12)
示例#14
0
    def test_goto_arith(self):
        a1 = set([
            LR0('E', 0, 2),
            LR0('T', 0, 0),
            LR0('T', 1, 0),
            LR0('F', 0, 0),
            LR0('F', 1, 0),
        ])

        a2 = set([
            LR0('E', 0, 1),
        ])

        a3 = set([
            LR0('T', 0, 3),
        ])

        self.assertTrue(a1 == goto(
            set([LR0(self.StartExtendedSymbol, 0, 1),
                 LR0('E', 0, 1)]), '+', self.arith))
        self.assertTrue(a2 == goto(set([LR0('E', 0, 0)]), 'E', self.arith))
        self.assertTrue(
            a3 == goto(set([
                LR0('T', 0, 2),
                LR0('F', 0, 0),
                LR0('F', 1, 0),
            ]), 'F', self.arith))
示例#15
0
   def setUp(self):
      self.lrvalue = grammar.Grammar(None, ('=', '*', ';', 'id', 'num'))
      self.symbol_table = dict()
      self.last_value = None

      def set_var(lv, rv): 
         self.symbol_table[lv] = rv; 
         return self.symbol_table[lv]

      def get_var(rv): 
         if rv in self.symbol_table:
            return self.symbol_table[rv]
         
         raise KeyError(rv)

      def grab_last_value(v):
         self.last_value = v if isinstance(v, int) else self.symbol_table[v]
         return v

      self.lrvalue.augment('S')

      self.lrvalue.add_rule('S', ['E', ';', 'S',   lambda e, s: s])
      self.lrvalue.add_rule('S', ['E', ';',        lambda v: v])
      self.lrvalue.add_rule('E', ['L', '=', 'R',   set_var])
      self.lrvalue.add_rule('E', ['R',             grab_last_value])
      self.lrvalue.add_rule('L', ['*', 'R',        get_var])
      self.lrvalue.add_rule('L', ['id',            lambda v: v])
      self.lrvalue.add_rule('R', ['L',             lambda v: v])
      self.lrvalue.add_rule('R', ['num',           lambda v: v])

      self.action_table, self.goto_table, self.start_state = build_parsing_table_lalr(self.lrvalue, LR0(self.lrvalue.START, 0, 0), False)
      self.driver = Driver(self.action_table, self.goto_table, self.start_state)
示例#16
0
 def test_reduce_reduce_conflict(self):
     self.assertRaisesRegexp(ReduceReduce, "during process '#' terminal",
                             build_parsing_table, self.reduce_reduce,
                             LR0(self.StartExtendedSymbol, 0, 0), False)
示例#17
0
def probe(*args):
    print "--", len(args), "-", " ".join(map(str, args))


def prompt(*args):
    print ">>> ",


grammar = from_string(rpcalc_grammar,
                      'input',
                      print_result=print_result,
                      probe=probe,
                      prompt=prompt,
                      up=lambda x: x,
                      add=lambda x, y: x + y,
                      sub=lambda x, y: x - y,
                      mul=lambda x, y: x * y,
                      div=lambda x, y: x / y,
                      mod=lambda x, y: x % y,
                      neg=lambda x: -x)

states, gotos, first = build_parsing_table(grammar, LR0(grammar.START, 0, 0))
driver = Driver(states, gotos, first)

print "Reverse polish calculator. Write expressions like "
print " >>> 2 + 3       (result in 2 + 3 = 5)  or "
print " >>> 2 + 4 * 5   (result in 2 + (4 * 5) = 22)"
print
prompt()
driver.parse(CalcLexer(sys.stdin))
示例#18
0
    def test_action_table(self):
        states_shifts_reduce_actions = [
            (frozenset([
                LR0(self.arith.START, 0, 0),
                LR0('S', 0, 0),
                LR0('E', 0, 0),
                LR0('E', 1, 0),
            ]), (('id', 2), ('let', 4)), ()),
            (frozenset([
                LR0(self.arith.START, 0, 1),
            ]), (), ()),
            (frozenset([
                LR0('E', 0, 1),
            ]), (), ()),
            (frozenset([
                LR0('S', 0, 1),
            ]), (), ()),
            (frozenset([
                LR0('E', 1, 1),
                LR0(self.arith.ACTION_INSIDE % (1, 'push'), 0, 0),
            ]), (), ()),
            (frozenset([
                LR0('E', 1, 2),
            ]), (('(', 9), ), ()),
            (frozenset([
                LR0('E', 1, 4),
            ]), ((')', 8), ), ()),
            (frozenset([
                LR0('E', 1, 6),
            ]), (), ()),
            (frozenset([
                LR0('E', 1, 5),
                LR0(self.arith.ACTION_INSIDE % (2, 'pop'), 0, 0),
            ]), (), ()),
            (frozenset([
                LR0('E', 1, 3),
                LR0('E', 0, 0),
                LR0('E', 1, 0),
            ]), (('id', 2), ('let', 4)), ()),
        ]

        self.assertTrue(
            len(states_shifts_reduce_actions) == len(self.action_table.keys()))

        for state, shifts, reduces in states_shifts_reduce_actions:
            h = hash(state)

            self.assertTrue(
                len(shifts) == len(
                    filter(lambda action: "Shift" in str(action),
                           self.action_table[h].values())))

            if not shifts:
                continue
            keys, ids = zip(*shifts)
            found_ids = [
                i for i in range(len(states_shifts_reduce_actions))
                if ("Shift %s" % hash(states_shifts_reduce_actions[i][0])
                    ) in map(lambda a: str(a), self.action_table[h].values())
            ]
            found_keys = self.action_table[h].keys()

            self.assertTrue(frozenset(ids) == frozenset(found_ids))
            self.assertTrue(frozenset(keys) == frozenset(found_keys))
示例#19
0
    def test_canonical_collection_lr_value(self):
        collection = canonical_collection(self.lrvalue,
                                          LR0(self.StartExtendedSymbol, 0, 0))
        self.assertTrue(len(collection) == 10)

        states = frozenset([
            frozenset([
                LR0(self.StartExtendedSymbol, 0, 0),
                LR0('S', 0, 0),
                LR0('S', 1, 0),
                LR0('L', 0, 0),
                LR0('L', 1, 0),
                LR0('R', 0, 0),
            ]),
            frozenset([
                LR0(self.StartExtendedSymbol, 0, 1),
            ]),
            frozenset([
                LR0('S', 0, 1),
                LR0('R', 0, 1),
            ]),
            frozenset([
                LR0('S', 1, 1),
            ]),
            frozenset([
                LR0('L', 0, 1),
                LR0('L', 0, 0),
                LR0('L', 1, 0),
                LR0('R', 0, 0),
            ]),
            frozenset([
                LR0('L', 1, 1),
            ]),
            frozenset([
                LR0('S', 0, 2),
                LR0('L', 0, 0),
                LR0('L', 1, 0),
                LR0('R', 0, 0),
            ]),
            frozenset([
                LR0('L', 0, 2),
            ]),
            frozenset([
                LR0('R', 0, 1),
            ]),
            frozenset([
                LR0('S', 0, 3),
            ]),
        ])

        self.assertTrue(states == collection)
示例#20
0
    def test_cannonical_collection(self):
        collection = canonical_collection(self.arith,
                                          LR0(self.arith.START, 0, 0))

        states = frozenset([
            frozenset([
                LR0(self.arith.START, 0, 0),
                LR0('S', 0, 0),
                LR0('E', 0, 0),
                LR0('E', 1, 0),
            ]),
            frozenset([
                LR0(self.arith.START, 0, 1),
            ]),
            frozenset([
                LR0('E', 0, 1),
            ]),
            frozenset([
                LR0('S', 0, 1),
            ]),
            frozenset([
                LR0('E', 1, 1),
                LR0(self.arith.ACTION_INSIDE % (1, 'push'), 0, 0),
            ]),
            frozenset([
                LR0('E', 1, 2),
            ]),
            frozenset([
                LR0('E', 1, 4),
            ]),
            frozenset([
                LR0('E', 1, 6),
            ]),
            frozenset([
                LR0('E', 1, 5),
                LR0(self.arith.ACTION_INSIDE % (2, 'pop'), 0, 0),
            ]),
            frozenset([
                LR0('E', 1, 3),
                LR0('E', 0, 0),
                LR0('E', 1, 0),
            ]),
        ])

        self.assertTrue(states == collection)
示例#21
0
    def test_canonical_collection_arith(self):
        collection = canonical_collection(self.arith,
                                          LR0(self.StartExtendedSymbol, 0, 0))
        self.assertTrue(len(collection) == 12)

        states = frozenset([
            frozenset([
                LR0(self.StartExtendedSymbol, 0, 0),
                LR0('E', 0, 0),
                LR0('E', 1, 0),
                LR0('T', 0, 0),
                LR0('T', 1, 0),
                LR0('F', 0, 0),
                LR0('F', 1, 0),
            ]),
            frozenset([
                LR0(self.StartExtendedSymbol, 0, 1),
                LR0('E', 0, 1),
            ]),
            frozenset([
                LR0('E', 1, 1),
                LR0('T', 0, 1),
            ]),
            frozenset([
                LR0('F', 1, 1),
            ]),
            frozenset([
                LR0('F', 0, 1),
                LR0('E', 0, 0),
                LR0('E', 1, 0),
                LR0('T', 0, 0),
                LR0('T', 1, 0),
                LR0('F', 0, 0),
                LR0('F', 1, 0),
            ]),
            frozenset([
                LR0('T', 1, 1),
            ]),
            frozenset([
                LR0('E', 0, 2),
                LR0('T', 0, 0),
                LR0('T', 1, 0),
                LR0('F', 0, 0),
                LR0('F', 1, 0),
            ]),
            frozenset([
                LR0('T', 0, 2),
                LR0('F', 0, 0),
                LR0('F', 1, 0),
            ]),
            frozenset([
                LR0('E', 0, 1),
                LR0('F', 0, 2),
            ]),
            frozenset([
                LR0('E', 0, 3),
                LR0('T', 0, 1),
            ]),
            frozenset([
                LR0('T', 0, 3),
            ]),
            frozenset([
                LR0('F', 0, 3),
            ]),
        ])

        self.assertTrue(states == collection)
示例#22
0
    def test_goto_table(self):
        states_gotos = [
            (frozenset([
                LR0(self.arith.START, 0, 0),
                LR0('S', 0, 0),
                LR0('E', 0, 0),
                LR0('E', 1, 0),
            ]), (('S', 1), ('id', 2), ('E', 3), ('let', 4))),
            (frozenset([
                LR0(self.arith.START, 0, 1),
            ]), ()),
            (frozenset([
                LR0('E', 0, 1),
            ]), ()),
            (frozenset([
                LR0('S', 0, 1),
            ]), ()),
            (frozenset([
                LR0('E', 1, 1),
                LR0(self.arith.ACTION_INSIDE % (1, 'push'), 0, 0),
            ]), ((self.arith.ACTION_INSIDE % (1, 'push'), 5), )),
            (frozenset([
                LR0('E', 1, 2),
            ]), (('(', 9), )),
            (frozenset([
                LR0('E', 1, 4),
            ]), ((')', 8), )),
            (frozenset([
                LR0('E', 1, 6),
            ]), ()),
            (frozenset([
                LR0('E', 1, 5),
                LR0(self.arith.ACTION_INSIDE % (2, 'pop'), 0, 0),
            ]), ((self.arith.ACTION_INSIDE % (2, 'pop'), 7), )),
            (frozenset([
                LR0('E', 1, 3),
                LR0('E', 0, 0),
                LR0('E', 1, 0),
            ]), (('E', 6), ('id', 2), ('let', 4))),
        ]

        checked = 0
        for state, gotos in states_gotos:
            h = hash(state)
            if not gotos:
                self.assertTrue(h not in self.goto_table)
                continue

            checked += 1
            expected_keys, expected_states_id = zip(*gotos)

            found_gotos_keys = frozenset(self.goto_table[h].keys())
            found_gotos_hashs = frozenset(self.goto_table[h].values())

            self.assertTrue(frozenset(expected_keys) == found_gotos_keys)
            self.assertTrue(
                frozenset(
                    [hash(states_gotos[i][0])
                     for i in expected_states_id]) == found_gotos_hashs)

        self.assertTrue(checked == len(self.goto_table.keys()))