Experimental parser: abstract lexing

tools/lexer_generator/automata_test.py

 # Copyright 2013 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
 #       disclaimer in the documentation and/or other materials provided
@@ skipping 66 matching lines @@
             self.assertTrue(automaton.matches(string))
         for string in not_matches:
           for automaton in automata:
             self.assertFalse(automaton.matches(string))
 
     def test_can_construct_dot(self):
       for (regex, matches, not_matches) in self.__test_data:
         for automaton in build_automata(regex):
           automaton.to_dot()
 
-    def test_actions(self):
-      left_action = simple_action("LEFT_ACTION")
-      right_action = simple_action("RIGHT_ACTION")
-      left = RegexParser.parse("left")
-      right = RegexParser.parse("right")
-      left = NfaBuilder.add_action(left, left_action)
-      right = NfaBuilder.add_action(right, right_action)
-      composite = ('ONE_OR_MORE', NfaBuilder.or_graphs([left, right]))
-      nfa = NfaBuilder().nfa(composite)
-      dfa = dfa_from_nfa(nfa)
-      def verify(string, expected):
-        actions = list(dfa.collect_actions(string))
-        self.assertEqual(len(expected), len(actions))
-        for i, action in enumerate(actions):
-          self.assertEqual(action, expected[i])
-      def verify_miss(string, expected):
-        verify(string, expected + [Dfa.miss_action()])
-      def verify_hit(string, expected):
-        verify(string, expected + [Dfa.terminal_action()])
-      (l, r) = left_action, right_action
-      verify_hit("left", [l])
-      verify_miss("lefta", [l])
-      verify_hit("leftrightleftright", [l, r, l, r])
-      verify_miss("leftrightleftrightx", [l, r, l, r])
-
     def test_minimization(self):
       def empty_node():
         return { 'transitions' : {}, 'terminal' : False, 'action' : None }
       mapping = { k : empty_node() for k in ['S_0', 'S_1', 'S_2', 'S_3'] }
       key_a = TransitionKey.single_char('a')
       key_b = TransitionKey.single_char('b')
       key_c = TransitionKey.single_char('c')
 
       mapping['S_0']['transitions'][key_a] = 'S_1'
       mapping['S_0']['transitions'][key_b] = 'S_2'
       mapping['S_1']['transitions'][key_c] = 'S_3'
       mapping['S_2']['transitions'][key_c] = 'S_3'
       mapping['S_3']['terminal'] = True
 
       mdfa = Dfa('S_0', mapping).minimize()
       self.assertEqual(3, mdfa.node_count())