Experimental parser: cleanup after grammar refactor

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 22 matching lines @@
 
 def dfa_from_nfa(nfa):
   (start_name, dfa_nodes) = nfa.compute_dfa()
   return Dfa(start_name, dfa_nodes)
 
 def build_automata(string):
   nfa = NfaBuilder().nfa(RegexParser.parse(string))
   dfa = dfa_from_nfa(nfa)
   return (nfa, dfa, dfa.minimize())
 
+def simple_action(string):
+  return Action(None, (string, None))
+
 class AutomataTestCase(unittest.TestCase):
 
     # (pattern, should match, should not match)
     __test_data = [
       ("a", ["a"], ["b", ""]),
       ("ab", ["ab"], ["bb", ""]),
       ("a+b", ["ab", "aab", "aaab"], ["a", "b", ""]),
       ("a?b", ["ab", "b"], ["a", "c", ""]),
       ("a*b", ["ab", "aaab", "b"], ["a", "c", ""]),
       ("a|b", ["a", "b"], ["ab", "c", ""]),
@@ skipping 21 matching lines @@
         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 = Action("LEFT_ACTION")
-      right_action = Action("RIGHT_ACTION")
+      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 + [Action('MISS',)])
+        verify(string, expected + [Dfa.miss_action()])
       def verify_hit(string, expected):
-        verify(string, expected + [Action('TERMINATE',)])
+        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])