Experimental parser: action 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
 #       with the distribution.
 #     * Neither the name of Google Inc. nor the names of its
 #       contributors may be used to endorse or promote products derived
 #       from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import unittest
+from automaton import Action
 from regex_parser import RegexParser
 from nfa_builder import NfaBuilder
 from dfa import Dfa
 
 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))
@@ skipping 34 matching lines @@
           self.assertFalse(nfa.matches(string))
           self.assertFalse(dfa.matches(string))
 
     def test_can_construct_dot(self):
       for (regex, matches, not_matches) in self.__test_data:
         (nfa, dfa) = build_automata(regex)
         nfa.to_dot()
         dfa.to_dot()
 
     def test_actions(self):
-      left_action = ("LEFT_ACTION", "LEFT_CONDITION")
-      right_action = ("RIGHT_ACTION", "RIGHT_CONDITION")
+      left_action = Action("LEFT_ACTION")
+      right_action = 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 + [('MISS',)])
+        verify(string, expected + [Action('MISS',)])
       def verify_hit(string, expected):
-        verify(string, expected + [('TERMINATE',)])
+        verify(string, expected + [Action('TERMINATE',)])
       (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):
       for (regex, matches, not_matches) in self.__test_data:
         (nfa, dfa) = build_automata(regex)
         dfa.minimize()