Add some test coverage to merge-business-hours.

ealter · ealter · commit d910118622b3 · 2017-08-01T21:58:55.000-07:00
diff --git a/.gitignore b/.gitignore
@@ -7,3 +7,4 @@
 /dist
 /venv
 machine.vim
+*.swp
diff --git a/tests/machines/merge_business_hours/merge_business_hours_test.py b/tests/machines/merge_business_hours/merge_business_hours_test.py
@@ -0,0 +1,165 @@
+from unittest import mock
+
+import pytest
+
+import vim_turing_machine.machines.merge_business_hours.merge_business_hours
+import vim_turing_machine.struct
+import vim_turing_machine.turing_machine
+from vim_turing_machine.constants import INITIAL_STATE
+from vim_turing_machine.constants import NO_FINAL_STATE
+from vim_turing_machine.constants import YES_FINAL_STATE
+from vim_turing_machine.machines.merge_business_hours.merge_business_hours import invert_bit
+from vim_turing_machine.machines.merge_business_hours.merge_business_hours import invert_direction
+from vim_turing_machine.machines.merge_business_hours.merge_business_hours import MergeBusinessHoursGenerator
+from vim_turing_machine.struct import BACKWARDS
+from vim_turing_machine.struct import FORWARDS
+from vim_turing_machine.turing_machine import TuringMachine
+
+
+@pytest.yield_fixture(autouse=True)
+def mock_blank_character():
+    """Change the blank character to be a space so that it's easier to write test cases."""
+    with mock.patch.object(
+        vim_turing_machine.turing_machine,
+        'BLANK_CHARACTER',
+        ' ',
+    ):
+        with mock.patch.object(
+            vim_turing_machine.struct,
+            'VALID_CHARACTERS',
+            ('0', '1', ' '),
+        ):
+            with mock.patch.object(
+                vim_turing_machine.machines.merge_business_hours.merge_business_hours,
+                'BLANK_CHARACTER',
+                ' ',
+            ):
+                with mock.patch.object(
+                    vim_turing_machine.machines.merge_business_hours.merge_business_hours,
+                    'VALID_CHARACTERS',
+                    ('0', '1', ' '),
+                ):
+                    yield
+
+
+@pytest.fixture
+def merger():
+    return MergeBusinessHoursGenerator(num_bits=3)
+
+
+def run_machine(transitions, tape, initial_position=0, assert_tape_not_changed=False):
+    machine = TuringMachine(list(transitions), quiet=True)
+    machine.run(tape[:], max_steps=10000, initial_cursor_position=initial_position)
+
+    if assert_tape_not_changed:
+        assert_tape(machine, tape)
+
+    return machine
+
+
+def assert_cursor_at_end_of_output(machine):
+    end = len(machine.tape) - 1
+    while end > 0 and machine.tape[end] == ' ':
+        end -= 1
+
+    assert machine.cursor_position == end
+
+
+def assert_tape(machine, expected_tape):
+    # Ignore any blanks at the end
+    assert expected_tape == ''.join(machine.tape).rstrip()
+
+
+def test_invert_bit():
+    assert invert_bit('0') == '1'
+    assert invert_bit('1') == '0'
+    with pytest.raises(AssertionError):
+        invert_bit('not_valid')
+
+
+def test_invert_direction():
+    assert invert_direction(FORWARDS) == BACKWARDS
+    assert invert_direction(BACKWARDS) == FORWARDS
+    with pytest.raises(AssertionError):
+        invert_direction('not_valid')
+
+
+def test_move_n_bits(merger):
+    machine = run_machine(
+        merger.move_n_bits(
+            initial_state=INITIAL_STATE,
+            direction=FORWARDS,
+            final_state=YES_FINAL_STATE,
+            num_bits=4,
+        ),
+        tape='01010111',
+        assert_tape_not_changed=True,
+    )
+
+    assert machine.cursor_position == 3
+
+
+def test_move_to_blank_spaces(merger):
+    machine = run_machine(
+        merger.move_to_blank_spaces(
+            initial_state=INITIAL_STATE,
+            direction=FORWARDS,
+            final_state=YES_FINAL_STATE,
+            final_character=' ',
+            final_direction=BACKWARDS,
+            num_blanks=2,
+        ),
+        tape='01 1111 10',
+        assert_tape_not_changed=True,
+    )
+
+    assert machine.cursor_position == 6  # End of the 1111
+
+
+def test_copy_bits_to_end_of_output(merger):
+    machine = run_machine(
+        merger.copy_bits_to_end_of_output(
+            initial_state=INITIAL_STATE,
+            num_bits=3,
+            final_state=YES_FINAL_STATE,
+        ),
+        tape='10111 01',
+    )
+
+    assert_tape(machine, '   11 01101')
+    assert_cursor_at_end_of_output(machine)
+
+
+@pytest.mark.parametrize('tape, final_state', [
+    ('101 100110', NO_FINAL_STATE),
+    ('101 100100', YES_FINAL_STATE),
+    ('101 111100', YES_FINAL_STATE),
+])
+def test_compare_two_sequential_numbers(merger, tape, final_state):
+    machine = run_machine(
+        merger.compare_two_sequential_numbers(
+            initial_state=INITIAL_STATE,
+            greater_than_or_equal_to_state=YES_FINAL_STATE,
+            less_than_state=NO_FINAL_STATE,
+        ),
+        tape=tape,
+        initial_position=len(tape) - 1,
+        assert_tape_not_changed=True,
+    )
+
+    assert_cursor_at_end_of_output(machine)
+    assert machine.current_state == final_state
+
+
+def test_erase_number(merger):
+    machine = run_machine(
+        merger.erase_number(
+            initial_state=INITIAL_STATE,
+            final_state=YES_FINAL_STATE,
+        ),
+        tape='100101110',
+        initial_position=5,  # end of 101
+    )
+
+    assert machine.cursor_position == 2
+    assert_tape(machine, '100   110')
diff --git a/vim_turing_machine/machines/merge_business_hours/merge_business_hours.py b/vim_turing_machine/machines/merge_business_hours/merge_business_hours.py
@@ -200,22 +200,6 @@ def copy_closing_hour_and_merge(self, initial_state, final_state):
 
         return transitions
 
-    def invert_bit(self, bit_value):
-        if bit_value == '0':
-            return '1'
-        elif bit_value == '1':
-            return '0'
-        else:
-            raise AssertionError('Invalid bit {}'.format(bit_value))
-
-    def invert_direction(self, direction):
-        if direction == BACKWARDS:
-            return FORWARDS
-        elif direction == FORWARDS:
-            return BACKWARDS
-        else:
-            raise AssertionError('Invalid direction {}'.format(direction))
-
     def noop_when_non_blank(self, state, direction):
         return (
             StateTransition(
@@ -478,7 +462,7 @@ def about_to_compare_bits_state(bit_index, bit_value):
                     # If the numbers are not equal
                     StateTransition(
                         previous_state=about_to_compare_bits_state(bit_index, bit_value),
-                        previous_character=self.invert_bit(bit_value),
+                        previous_character=invert_bit(bit_value),
                         next_state=(
                             FOUND_GREATER_THAN_OR_EQUAL_TO_STATE
                             if (
@@ -487,12 +471,12 @@ def about_to_compare_bits_state(bit_index, bit_value):
                             )
                             else FOUND_LESS_THAN_STATE
                         ),
-                        next_character=self.invert_bit(bit_value),
-                        tape_pointer_direction=self.invert_direction(direction),
+                        next_character=invert_bit(bit_value),
+                        tape_pointer_direction=invert_direction(direction),
                     )
                 )
 
-            direction = self.invert_direction(direction)
+            direction = invert_direction(direction)
 
         # After we've determined the answer, we need to move to the end of the output array
         transitions.extend(
@@ -668,6 +652,24 @@ def check_if_there_is_any_input_left(self, initial_state, final_state):
         return transitions
 
 
+def invert_bit(bit_value):
+    if bit_value == '0':
+        return '1'
+    elif bit_value == '1':
+        return '0'
+    else:
+        raise AssertionError('Invalid bit {}'.format(bit_value))
+
+
+def invert_direction(direction):
+    if direction == BACKWARDS:
+        return FORWARDS
+    elif direction == FORWARDS:
+        return BACKWARDS
+    else:  # pragma: no cover
+        raise AssertionError('Invalid direction {}'.format(direction))
+
+
 if __name__ == '__main__':
     input_string = json.loads(sys.argv[1])
     num_bits = int(sys.argv[2])
@@ -678,4 +680,4 @@ def check_if_there_is_any_input_left(self, initial_state, final_state):
     merge_business_hours = TuringMachine(gen.merge_business_hours_transitions(), debug=True)
     merge_business_hours.run(initial_tape=initial_tape, max_steps=5000)
 
-    print(decode_hours(''.join(merge_business_hours.get_tape()), num_bits))
+    print(decode_hours(''.join(merge_business_hours.tape), num_bits))
diff --git a/vim_turing_machine/turing_machine.py b/vim_turing_machine/turing_machine.py
@@ -25,7 +25,7 @@ class TooManyStepsException(Exception):
 
 class TuringMachine(object):
 
-    def __init__(self, state_transitions, debug=False):
+    def __init__(self, state_transitions, debug=False, quiet=False):
         validate_state_transitions(state_transitions)
 
         self._state_transitions = state_transitions
@@ -34,65 +34,68 @@ def __init__(self, state_transitions, debug=False):
             for state in state_transitions
         }
         self._debug = debug
+        self._quiet = quiet
         self.initialize_machine(tape=[])
 
-    def initialize_machine(self, tape):
-        self._tape = list(tape)[:]  # Copy the initial tape since we mutate it
-        self._cursor_position = 0
-        self._current_state = INITIAL_STATE
+    def initialize_machine(self, tape, initial_cursor_position=0):
+        self.tape = list(tape)[:]  # Copy the initial tape since we mutate it
+        self.cursor_position = initial_cursor_position
+        self.current_state = INITIAL_STATE
         self._num_steps = 0
 
     def get_state_transition(self):
         try:
             return self._state_transition_mapping[
-                (self._current_state, self._tape[self._cursor_position])
+                (self.current_state, self.tape[self.cursor_position])
             ]
         except KeyError:
             raise MissingStateTransition(
-                (self._current_state, self._tape[self._cursor_position])
+                (self.current_state, self.tape[self.cursor_position])
             )
 
     def step(self):
         """This implements an infinitely long tape in the right direction, but
         will error if you go beyond position 0"""
         transition = self.get_state_transition()
 
-        self._tape[self._cursor_position] = transition.next_character
+        self.tape[self.cursor_position] = transition.next_character
 
-        self._cursor_position += transition.tape_pointer_direction
+        self.cursor_position += transition.tape_pointer_direction
 
-        if self._cursor_position < 0:
+        if self.cursor_position < 0:
             raise NegativeTapePositionException
 
         # Make sure we haven't run more than 1 past the end of the tape. This
         # should never happen since we append to the tape over time.
-        assert self._cursor_position <= len(self._tape)
+        assert self.cursor_position <= len(self.tape)
 
-        if self._cursor_position >= len(self._tape):
+        if self.cursor_position >= len(self.tape):
             # Fake the infinite tape by adding a blank character under the
             # cursor.
-            self._tape.append(BLANK_CHARACTER)
+            self.tape.append(BLANK_CHARACTER)
 
-        self._current_state = transition.next_state
+        self.current_state = transition.next_state
 
-        if self._current_state in FINAL_STATES:
+        if self.current_state in FINAL_STATES:
             self.final_state()
         elif self._debug:
             self.print_tape()
 
     def final_state(self):
-        print('Program complete. Final state: {}'.format(self._current_state))
-        print(
-            'The program completed in {} steps using a machine with {} transitions'.format(
-                self._num_steps,
-                len(self._state_transitions)
+        if not self._quiet:
+            print('Program complete. Final state: {}'.format(self.current_state))
+            print(
+                'The program completed in {} steps using a machine with {} transitions'.format(
+                    self._num_steps,
+                    len(self._state_transitions)
+                )
             )
-        )
-        self.print_tape()
+            self.print_tape()
+
         raise StopIteration
 
-    def run(self, initial_tape, max_steps=None):
-        self.initialize_machine(initial_tape)
+    def run(self, initial_tape, max_steps=None, initial_cursor_position=0):
+        self.initialize_machine(initial_tape, initial_cursor_position=initial_cursor_position)
 
         if self._debug:
             self.print_tape()
@@ -109,22 +112,19 @@ def run(self, initial_tape, max_steps=None):
 
     def print_tape(self):
         tape = ''
-        for i, character in enumerate(self._tape):
-            if i == self._cursor_position:
+        for i, character in enumerate(self.tape):
+            if i == self.cursor_position:
                 tape += '{}{}{}{}'.format(colored.bg('red'), colored.fg('white'), character, colored.attr('reset'))
             else:
                 tape += character
 
-            if i != len(self._tape) - 1:
+            if i != len(self.tape) - 1:
                 tape += ' | '
 
         print(tape)
-        print('State: {}'.format(self._current_state))
+        print('State: {}'.format(self.current_state))
         print()  # Add empty line
 
-    def get_tape(self):
-        return self._tape
-
 
 def validate_state_transitions(state_transitions):
     seen = defaultdict(list)

-Original file line number
+Diff line change
 /dist
 /venv
 machine.vim
 +*.swp