Revert "Fix stochastic behavior and refactor tests to use unittest"

This reverts commit a8a4bf2.

Author: meatballs

src/axelrod_fortran/player.py

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

tests/test_player.py

@@ -1,99 +1,91 @@
-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
 
 
-class TestAll(unittest.TestCase):
-    def test_init(self):
-        for strategy in all_strategies:
+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):
+
             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(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]
+
+            # 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]

tests/test_titfortat.py

@@ -1,27 +1,26 @@
-import unittest
-
 from axelrod_fortran.player import Player
 import axelrod as axl
 from axelrod.action import Action
 
 C, D = Action.C, Action.D
 
 
-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_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
 
-    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(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
+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