Fix stochastic behavior and refactor tests to use unittest

Author: marcharper

src/axelrod_fortran/player.py

@@ -1,3 +1,5 @@
+import random
+
 import axelrod as axl
 from axelrod.interaction_utils import compute_final_score
 from axelrod.action import Action
@@ -57,15 +59,15 @@ def original_function(self, value):
         self.__original_function.restype = c_int
 
     def original_strategy(
-        self, their_last_move, move_number, my_score, their_score, noise,
+        self, their_last_move, move_number, my_score, their_score, random_value,
         my_last_move
     ):
         args = (
             c_int(their_last_move), c_int(move_number), c_int(my_score),
-            c_int(their_score), c_float(noise), c_int(my_last_move))
+            c_int(their_score), c_float(random_value), c_int(my_last_move))
         return self.original_function(*[byref(arg) for arg in args])
 
-    def strategy(self, opponent, noise=0):
+    def strategy(self, opponent):
         if not self.history:
             their_last_move = 0
             scores = (0, 0)
@@ -76,8 +78,9 @@ def strategy(self, opponent, noise=0):
                                          game=self.game)
             my_last_move = original_actions[self.history[-1]]
         move_number = len(self.history) + 1
+        random_value = random.random()
         original_action = self.original_strategy(
-            their_last_move, move_number, scores[0], scores[1], noise,
+            their_last_move, move_number, scores[0], scores[1], random_value,
             my_last_move)
         return actions[original_action]
 

tests/test_player.py

@@ -1,91 +1,99 @@
+from ctypes import c_int, c_float, POINTER
+import itertools
+import random
+import unittest
+
 from axelrod_fortran.strategies import all_strategies
 from axelrod_fortran import Player
 from axelrod import Alternator, Cooperator, Defector, Match, Game
 from axelrod.action import Action
-from ctypes import c_int, c_float, POINTER
-
-import itertools
 
 C, D = Action.C, Action.D
 
 
-def test_init():
-    for strategy in all_strategies:
-        player = Player(strategy)
-        assert player.classifier["stochastic"]
-        assert player.original_name == strategy
-        assert player.original_function.argtypes == (
-            POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int),
-            POINTER(c_float))
-        assert player.original_function.restype == c_int
-
-
-def test_matches():
-    for strategy in all_strategies:
-        for opponent in (Alternator, Cooperator, Defector):
-            players = (Player(strategy), opponent())
-            match = Match(players, turns=200)
-            assert all(
-                action in (C, D) for interaction in match.play()
-                for action in interaction)
-
-def test_noisy_matches():
-    for strategy in all_strategies:
-        for opponent in (Alternator, Cooperator, Defector):
-            players = (Player(strategy), opponent())
-            match = Match(players, turns=200, noise=0.5)
-            assert all(
-                action in (C, D) for interaction in match.play()
-                for action in interaction)
-
-def test_probend_matches():
-    for strategy in all_strategies:
-        for opponent in (Alternator, Cooperator, Defector):
-            players = (Player(strategy), opponent())
-            match = Match(players, prob_end=0.5, noise=0.5)
-            assert all(
-                action in (C, D) for interaction in match.play()
-                for action in interaction)
-
-def test_matches_with_different_game():
-    for strategy in all_strategies:
-        for opponent in (Alternator, Cooperator, Defector):
-            game = Game(r=4,s=0,p=2,t=6)
-            players = (Player(strategy, game=game), opponent())
-            match = Match(players, turns=200, game=game)
-            assert all(
-                action in (C, D) for interaction in match.play()
-                for action in interaction)
-
-
-def test_original_strategy():
-    """
-    Test original strategy against all possible first 5 moves of a Match
-    """
-    actions_to_scores = {(0, 0): (3, 3), (0, 1): (0, 5),
-                         (1, 0): (5, 0), (1, 1): (1, 1)}
-    for strategy in all_strategies:
-        for opponent_sequence in itertools.product((0, 1), repeat=5):
-
+class TestAll(unittest.TestCase):
+    def test_init(self):
+        for strategy in all_strategies:
             player = Player(strategy)
-
-            # Initial set up for empty history
-            my_score, their_score = 0, 0
-            move_number = 1
-            their_previous_action, my_action = 0, 0
-
-            for action in opponent_sequence:
-                my_action = player.original_strategy(
-                    their_last_move=their_previous_action,
-                    move_number=move_number,
-                    my_score=my_score,
-                    their_score=their_score,
-                    noise=0,
-                    my_last_move=my_action)
-
-                assert my_action in [0, 1]
-
-                scores = actions_to_scores[my_action, action]
-                their_previous_action = action
-                my_score += scores[0]
-                their_score += scores[1]
+            assert player.classifier["stochastic"]
+            assert player.original_name == strategy
+            assert player.original_function.argtypes == (
+                POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int),
+                POINTER(c_float))
+            assert player.original_function.restype == c_int
+
+    def test_matches(self):
+        for strategy in all_strategies:
+            for opponent in (Alternator, Cooperator, Defector):
+                players = (Player(strategy), opponent())
+                match = Match(players, turns=200)
+                assert all(
+                    action in (C, D) for interaction in match.play()
+                    for action in interaction)
+
+    def test_noisy_matches(self):
+        for strategy in all_strategies:
+            for opponent in (Alternator, Cooperator, Defector):
+                players = (Player(strategy), opponent())
+                match = Match(players, turns=200, noise=0.5)
+                assert all(
+                    action in (C, D) for interaction in match.play()
+                    for action in interaction)
+
+    def test_probend_matches(self):
+        for strategy in all_strategies:
+            for opponent in (Alternator, Cooperator, Defector):
+                players = (Player(strategy), opponent())
+                match = Match(players, prob_end=0.5)
+                assert all(
+                    action in (C, D) for interaction in match.play()
+                    for action in interaction)
+
+    def test_matches_with_different_game(self):
+        for strategy in all_strategies:
+            for opponent in (Alternator, Cooperator, Defector):
+                game = Game(r=4,s=0,p=2,t=6)
+                players = (Player(strategy, game=game), opponent())
+                match = Match(players, turns=200, game=game)
+                assert all(
+                    action in (C, D) for interaction in match.play()
+                    for action in interaction)
+
+    def test_random(self):
+        random.seed(10)
+        players = (Player("KRANDOMC"), Player("KRANDOMC"))
+        match = Match(players, 5)
+        expected = [(C, D), (C, D), (C, C), (C, D), (C, D)]
+        assert match.play() == expected
+
+    def test_original_strategy(self):
+        """
+        Test original strategy against all possible first 5 moves of a Match
+        """
+        actions_to_scores = {(0, 0): (3, 3), (0, 1): (0, 5),
+                             (1, 0): (5, 0), (1, 1): (1, 1)}
+        for strategy in all_strategies:
+            for opponent_sequence in itertools.product((0, 1), repeat=5):
+
+                player = Player(strategy)
+
+                # Initial set up for empty history
+                my_score, their_score = 0, 0
+                move_number = 1
+                their_previous_action, my_action = 0, 0
+
+                for action in opponent_sequence:
+                    my_action = player.original_strategy(
+                        their_last_move=their_previous_action,
+                        move_number=move_number,
+                        my_score=my_score,
+                        their_score=their_score,
+                        random_value=0,
+                        my_last_move=my_action)
+
+                    assert my_action in [0, 1]
+
+                    scores = actions_to_scores[my_action, action]
+                    their_previous_action = action
+                    my_score += scores[0]
+                    their_score += scores[1]

tests/test_titfortat.py

@@ -1,26 +1,27 @@
+import unittest
+
 from axelrod_fortran.player import Player
 import axelrod as axl
 from axelrod.action import Action
 
 C, D = Action.C, Action.D
 
 
-def test_versus_alternator():
-    players = (Player('ktitfortatc'), axl.Alternator())
-    match = axl.Match(players, 5)
-    expected = [(C, C), (C, D), (D, C), (C, D), (D, C)]
-    assert match.play() == expected
-
-
-def test_versus_cooperator():
-    players = (Player('ktitfortatc'), axl.Cooperator())
-    match = axl.Match(players, 5)
-    expected = [(C, C), (C, C), (C, C), (C, C), (C, C)]
-    assert match.play() == expected
+class TestAll(unittest.TestCase):
+    def test_versus_alternator(self):
+        players = (Player('ktitfortatc'), axl.Alternator())
+        match = axl.Match(players, 5)
+        expected = [(C, C), (C, D), (D, C), (C, D), (D, C)]
+        assert match.play() == expected
 
+    def test_versus_cooperator(self):
+        players = (Player('ktitfortatc'), axl.Cooperator())
+        match = axl.Match(players, 5)
+        expected = [(C, C), (C, C), (C, C), (C, C), (C, C)]
+        assert match.play() == expected
 
-def test_versus_defector():
-    players = (Player('ktitfortatc'), axl.Defector())
-    match = axl.Match(players, 5)
-    expected = [(C, D), (D, D), (D, D), (D, D), (D, D)]
-    assert match.play() == expected
+    def test_versus_defector(self):
+        players = (Player('ktitfortatc'), axl.Defector())
+        match = axl.Match(players, 5)
+        expected = [(C, D), (D, D), (D, D), (D, D), (D, D)]
+        assert match.play() == expected