Included gomill framework for SGF and GTP support, and sketched out SGF game-loading code.

gomill/gomill_tests/gtp_state_test_support.py

@@ -0,0 +1,106 @@
+"""Support code for testing gtp_states."""
+
+from gomill import gtp_states
+from gomill.common import *
+
+class Player(object):
+    """Player (stateful move generator) for testing gtp_states.
+
+    Public attributes:
+      last_game_state -- the Game_state from the last genmove-like command
+
+    """
+
+    def __init__(self):
+        self.next_move = None
+        self.next_comment = None
+        self.next_cookie = None
+        self.last_game_state = None
+        self.resign_next_move = False
+
+    def set_next_move(self, vertex, comment=None, cookie=None):
+        """Specify what to return from the next genmove-like command."""
+        self.next_move = move_from_vertex(vertex, 19)
+        self.next_comment = comment
+        self.next_cookie = cookie
+
+    def set_next_move_resign(self):
+        self.resign_next_move = True
+
+    def genmove(self, game_state, player):
+        """Move generator returns points from the move list.
+
+        game_state -- gtp_states.Game_state
+        player     -- 'b' or 'w'
+
+        """
+        self.last_game_state = game_state
+        # Freeze the move_history as we saw it
+        self.last_game_state.move_history = self.last_game_state.move_history[:]
+
+        result = gtp_states.Move_generator_result()
+        if self.resign_next_move:
+            result.resign = True
+        elif self.next_move is not None:
+            result.move = self.next_move
+        else:
+            result.pass_move = True
+        if self.next_comment is not None:
+            result.comments = self.next_comment
+        if self.next_cookie is not None:
+            result.cookie = self.next_cookie
+        self.next_move = None
+        self.next_comment = None
+        self.next_cookie = None
+        self.resign_next_move = False
+        return result
+
+class Testing_gtp_state(gtp_states.Gtp_state):
+    """Variant of Gtp_state suitable for use in tests.
+
+    This doesn't read from or write to the filesystem.
+
+    """
+    def __init__(self, *args, **kwargs):
+        super(Testing_gtp_state, self).__init__(*args, **kwargs)
+        self._file_contents = {}
+
+    def _register_file(self, pathname, contents):
+        self._file_contents[pathname] = contents
+
+    def _load_file(self, pathname):
+        try:
+            return self._file_contents[pathname]
+        except KeyError:
+            raise EnvironmentError("unknown file: %s" % pathname)
+
+    def _save_file(self, pathname, contents):
+        if pathname == "force_fail":
+            open("/nonexistent_directory/foo.sgf", "w")
+        self._file_contents[pathname] = contents
+
+    def _choose_free_handicap_moves(self, number_of_stones):
+        """Implementation of place_free_handicap.
+
+        Returns for a given number of stones:
+         2 -- A1 A2 A3          (too many stones)
+         4 -- A1 A2 A3 pass     (pass isn't permitted)
+         5 -- A1 A2 A3 A4 A5    (which is ok)
+         6 -- A1 A2 A3 A4 A5 A1 (repeated point)
+         8 -- not even the right result type
+         otherwise Gtp_state default (which is to use the fixed handicap points)
+
+        """
+        if number_of_stones == 2:
+            return ((0, 0), (1, 0), (2, 0))
+        elif number_of_stones == 4:
+            return ((0, 0), (1, 0), (2, 0), None)
+        elif number_of_stones == 5:
+            return ((0, 0), (1, 0), (2, 0), (3, 0), (4, 0))
+        elif number_of_stones == 6:
+            return ((0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (0, 0))
+        elif number_of_stones == 8:
+            return "nonsense"
+        else:
+            return super(Testing_gtp_state, self).\
+                   _choose_free_handicap_moves(number_of_stones)