Example #1
0
    def test_zero_tables(self):
        """Test the corner case where n=0."""
        anti_tft_pattern = "DC"
        parameters = Plays(self_plays=0, op_plays=1, op_openings=0)

        tft_vs_alternator = [(C, C)] + [(D, D), (C, C)] * 5
        self.versus_test(
            axl.Alternator(),
            expected_actions=tft_vs_alternator,
            init_kwargs={
                "parameters": parameters,
                "pattern": anti_tft_pattern
            },
        )
Example #2
0
    def test_strategy(self):
        # Starts by Cooperating
        self.first_play_test(C)

        # Check if the turns played are greater than 5
        actions = [(C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C)]
        self.versus_test(axelrod.Cooperator(), expected_actions=actions)

        actions = [(C, D), (D, D), (D, D), (D, D), (D, D), (D, D), (D, D)]
        self.versus_test(axelrod.Defector(), expected_actions=actions)

        # Check for TFT behavior after 5 rounds
        actions = [(C, C), (C, D), (D, C), (C, D), (D, C), (C, D), (D, C)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions)
Example #3
0
def main():
    player = axl.ZDExtort2()
    opponent = axl.Alternator()
    axl.seed(0)
    match = axl.Match(players=(player, opponent), turns=20)
    interactions = match.play()
    df = pd.DataFrame(interactions,
                      columns=["(8/9, 1/2, 1/3, 0)", "Alternator"])
    df["Turn"] = df.index + 1
    df = df[["Turn", "(8/9, 1/2, 1/3, 0)", "Alternator"]]
    df = df.transpose()
    string = df.to_latex(header=False).replace("\\\\", "\\\\\\midrule", 1)
    with open("main.tex", "w") as f:
        f.write(string)
Example #4
0
    def test_strategy(self):
        # Test cooperate after opponent cooperates
        actions = [(C, C)] * 5
        self.versus_test(axelrod.Cooperator(), expected_actions=actions)

        # If opponent only defects then probability of cooperating is 0.
        actions = [(C, D), (D, D), (D, D), (D, D), (D, D)]
        self.versus_test(axelrod.Defector(), expected_actions=actions)

        # Stochastic response to defect
        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions,
                         seed=0)
        actions = [(C, C), (C, D), (C, C), (C, D), (D, C)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions,
                         seed=1)

        opponent = axelrod.MockPlayer(actions=[D, C, C, D])
        actions = [(C, D), (D, C), (C, C), (C, D), (C, D)]
        self.versus_test(opponent, expected_actions=actions, seed=8)
        opponent = axelrod.MockPlayer(actions=[D, C, C, D])
        actions = [(C, D), (D, C), (C, C), (C, D), (D, D)]
        self.versus_test(opponent, expected_actions=actions, seed=2)
Example #5
0
    def test_strategy(self):
        # If opponent defects more than once, cooperate forever.
        actions = [(D, C)] * 20
        self.versus_test(opponent=axelrod.Cooperator(), expected_actions=actions)

        actions = [(D, C), (D, D)] + [(C, C), (C, D)] * 20
        self.versus_test(opponent=axelrod.Alternator(), expected_actions=actions)

        opponent = axelrod.MockPlayer([D] + [C] * 19)
        actions = [(D, D)] + [(C, C)] * 19
        self.versus_test(opponent=opponent, expected_actions=actions)

        actions = [(D, D)] + [(C, D)] * 19
        self.versus_test(opponent=axelrod.Defector(), expected_actions=actions)
Example #6
0
    def test_strategy(self):
        # Starts by cooperating.
        self.first_play_test(C)

        player_history = [C, C, D, C, D, C, C, C, D, C, C, C, D, D, D, D, D, D]
        opp_history = [C, D] * 9
        actions = list(zip(player_history, opp_history))
        self.versus_test(axelrod.Alternator(), expected_actions=actions)

        player_history =  [C, D, C, D, C, C, C, C, C]
        opp_history = [D, C, D, C, D, C, C, C, C]
        actions = list(zip(player_history, opp_history))
        self.versus_test(axelrod.SuspiciousTitForTat(),
                         expected_actions=actions)
Example #7
0
    def test_strategy(self):
        actions = [(C, C)] * 100
        self.versus_test(axelrod.Cooperator(), expected_actions=actions)

        actions = [(C, D), (C, D), (D, D), (D, D)]
        self.versus_test(axelrod.Defector(), expected_actions=actions, seed=1)
        actions = [(C, D), (D, D), (D, D), (C, D)]
        self.versus_test(axelrod.Defector(), expected_actions=actions, seed=2)

        actions = [(C, D), (C, C), (D, C), (C, D), (D, C), (D, D), (C, D),
                   (D, C), (C, D)]
        self.versus_test(axelrod.SuspiciousTitForTat(),
                         expected_actions=actions,
                         seed=1)

        actions = [(C, C), (C, D), (D, C)] + [(D, D), (C, C)] * 3
        self.versus_test(axelrod.Alternator(),
                         expected_actions=actions,
                         seed=2)
        actions = [(C, C), (C, D), (C, C)] + [(D, D), (C, C)] * 3
        self.versus_test(axelrod.Alternator(),
                         expected_actions=actions,
                         seed=3)
Example #8
0
    def test_strategy(self):
        actions = [(C, C)] * 7
        self.versus_test(axelrod.Cooperator(), expected_actions=actions)

        actions = [(C, C), (C, D), (D, C)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions)

        opponent = axelrod.MockPlayer(actions=[D] * 8)
        actions = [(C, D)] * 2 + [(D, D)] * 5 + [(C, D)] + [(C, D)]
        self.versus_test(opponent, expected_actions=actions, seed=1)

        opponent = axelrod.MockPlayer(actions=[D] * 8)
        actions = [(C, D)] * 2 + [(D, D)] * 5 + [(C, D)] + [(D, D)]
        self.versus_test(opponent, expected_actions=actions, seed=2)
Example #9
0
    def test_strategy_mutually_cooperative(self):
        # tests states 2, 7, 14 and 11
        actions = [(C, C), (C, D), (D, C), (D, D), (C, C), (C, D)]
        self.versus_test(opponent=axl.Alternator(), expected_actions=actions)

        # tests states 1, 4 and 8
        actions = [(C, D), (C, D), (D, D), (C, C), (C, C), (C, D)]
        self.versus_test(opponent=axl.Cycler(["D", "D", "D", "C", "C"]),
                         expected_actions=actions)

        # tests states 3, 5
        actions = [(C, D), (C, C), (D, C), (D, D), (C, D)]
        self.versus_test(opponent=axl.SuspiciousTitForTat(),
                         expected_actions=actions)
Example #10
0
    def test_opponent_starting_moves_table(self):
        """A lookup table that always repeats the opponent's first move."""
        first_move_table = {((), (), (C, )): C, ((), (), (D, )): D}

        vs_alternator = [(C, C), (C, D)] * 5
        self.versus_test(axelrod.Alternator(),
                         expected_actions=vs_alternator,
                         init_kwargs={'lookup_dict': first_move_table})

        vs_initial_defector = [(C, D)] + [(D, C), (D, D)] * 10
        opponent = axelrod.MockPlayer(actions=[D, C])
        self.versus_test(opponent,
                         expected_actions=vs_initial_defector,
                         init_kwargs={'lookup_dict': first_move_table})
Example #11
0
 def test_defector_table_with_initial_cooperate(self):
     """
     Testing a lookup table that always defects IF there is enough history.
     """
     defector_table = {
         ((C, ), (D, ), ()): D,
         ((D, ), (D, ), ()): D,
         ((C, ), (C, ), ()): D,
         ((D, ), (C, ), ()): D
     }
     actions = [(C, C)] + [(D, D), (D, C)] * 4
     self.versus_test(axelrod.Alternator(),
                      expected_actions=actions,
                      init_kwargs={'lookup_dict': defector_table})
Example #12
0
 def test_reset_history_and_attributes(self):
     """Make sure resetting works correctly."""
     for opponent in [
             axl.Defector(),
             axl.Random(),
             axl.Alternator(),
             axl.Cooperator(),
     ]:
         player = self.player()
         clone = player.clone()
         match = axl.Match((player, opponent), turns=10, seed=111)
         match.play()
         player.reset()
         self.assertEqual(player, clone)
Example #13
0
 def test_defects_after_four_defections(self):
     # Forgives three defections
     defector_actions = [(C, D), (C, D), (C, D), (C, D), (D, D), (D, D)]
     self.versus_test(
         axelrod.Defector(),
         expected_actions=defector_actions,
         match_attributes={"length": 200},
     )
     alternator_actions = [(C, C), (C, D)] * 4 + [(D, C), (D, D)] * 2
     self.versus_test(
         axelrod.Alternator(),
         expected_actions=alternator_actions,
         match_attributes={"length": 200},
     )
Example #14
0
    def test_strategy(self):

        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
        self.versus_test(opponent=axl.Alternator(), expected_actions=actions)

        actions = [(C, D), (D, D), (D, D), (D, D), (C, D)]
        self.versus_test(opponent=axl.Defector(),
                         expected_actions=actions,
                         seed=0)

        actions = [(C, D), (D, D), (C, D), (D, D), (D, D)]
        self.versus_test(opponent=axl.Defector(),
                         expected_actions=actions,
                         seed=1)
 def test_wsls(self):
     """Tests that the player defined by the table for TFT is in fact
     WSLS (also known as Pavlov."""
     wsls_init_kwargs = {
         "transitions": ((1, C, 1, C), (1, D, 2, D), (2, C, 2, D), (2, D, 1, C)),
         "initial_state": 1,
         "initial_action": C,
     }
     expected = [(C, C), (C, D), (D, C), (D, D)] * 3
     self.versus_test(
         axelrod.Alternator(),
         expected_actions=expected,
         init_kwargs=wsls_init_kwargs,
     )
 def test_random_behavior2(self):
     actions = [
         (D, C),
         (C, D),
         (C, C),
         (C, D),
         (C, C),
         (D, D),
         (C, C),
         (D, D),
         (C, C),
         (D, D),
     ]
     self.versus_test(axl.Alternator(), expected_actions=actions, seed=2)
Example #17
0
    def test_strategy(self):
        # Starts by defecting.
        self.first_play_test(D)
        # Will do opposite of what opponent does.
        self.second_play_test(rCC=D, rCD=C, rDC=D, rDD=C)

        actions = [(D, C), (D, D), (C, C), (D, D), (C, C)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions)

        actions = [(D, C), (D, C), (D, C), (D, C), (D, C)]
        self.versus_test(axelrod.Cooperator(), expected_actions=actions)

        actions = [(D, D), (C, D), (C, D), (C, D), (C, D)]
        self.versus_test(axelrod.Defector(), expected_actions=actions)
Example #18
0
    def test_strategy(self):
        actions = [(C, C), (C, D)] * 3 + [(D, C), (D, D)] * 5
        self.versus_test(
            opponent=axl.Alternator(),
            expected_actions=actions,
            attrs={"is_alt": True},
        )

        actions = [(C, D)] * 14
        self.versus_test(
            opponent=axl.Defector(),
            expected_actions=actions,
            attrs={"is_alt": False},
        )
Example #19
0
    def test_strategy(self):
        # Cooperates initially (not stochastic)
        self.first_play_test(C, seed=1)
        self.first_play_test(C, seed=2)

        # Tests that if opponent has played all C then player chooses C.
        actions = [(C, C)] * 10
        self.versus_test(axelrod.Cooperator(),
                         expected_actions=actions,
                         seed=1)

        # Tests that if opponent has played all D then player chooses D.
        actions = [(C, D)] + [(D, D)] * 9
        self.versus_test(axelrod.Defector(), expected_actions=actions, seed=1)

        # Variable behaviour based on the history and stochastic behaviour
        actions = [(C, C), (C, D), (C, C), (D, D), (D, C), (C, D), (C, C),
                   (C, D), (D, C), (D, D)]
        self.versus_test(axelrod.Alternator(),
                         expected_actions=actions,
                         seed=1)

        actions = [(C, C), (C, D), (D, C), (D, D), (C, C), (C, D), (D, C),
                   (D, D), (D, C), (C, D)]
        self.versus_test(axelrod.Alternator(),
                         expected_actions=actions,
                         seed=2)

        opponent = axelrod.MockPlayer([C, C, D, D, D, D])
        actions = [(C, C), (C, C), (C, D), (C, D), (D, D), (D, D), (C, C),
                   (D, C), (C, D), (D, D)]
        self.versus_test(opponent, expected_actions=actions, seed=1)

        opponent = axelrod.MockPlayer([C, C, C, D, D, D])
        actions = [(C, C), (C, C), (C, C), (C, D), (D, D), (D, D), (C, C),
                   (C, C), (D, C), (D, D)]
        self.versus_test(opponent, expected_actions=actions, seed=2)
Example #20
0
    def test_strategy(self):
        self.first_play_test(C)
        self.second_play_test(rCC=C, rCD=D, rDC=C, rDD=D)

        # Play against opponents
        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions)

        actions = [(C, C), (C, C), (C, C), (C, C), (C, C)]
        self.versus_test(axelrod.Cooperator(), expected_actions=actions)

        actions = [(C, D), (D, D), (D, D), (D, D), (D, D)]
        self.versus_test(axelrod.Defector(), expected_actions=actions)

        # This behaviour is independent of knowledge of the Match length
        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions,
                         match_attributes={"length": -1})

        # We can also test against random strategies
        actions = [(C, D), (D, D), (D, C), (C, C), (C, D)]
        self.versus_test(axelrod.Random(), expected_actions=actions,
                         seed=0)

        actions = [(C, C), (C, D), (D, D), (D, C)]
        self.versus_test(axelrod.Random(), expected_actions=actions,
                         seed=1)

        #  If you would like to test against a sequence of moves you should use
        #  a MockPlayer
        opponent = axelrod.MockPlayer(actions=[C, D])
        actions = [(C, C), (C, D), (D, C), (C, D)]
        self.versus_test(opponent, expected_actions=actions)

        opponent = axelrod.MockPlayer(actions=[C, C, D, D, C, D])
        actions = [(C, C), (C, C), (C, D), (D, D), (D, C), (C, D)]
        self.versus_test(opponent, expected_actions=actions)
Example #21
0
    def test_strategy(self):
        # Our Player (SteinAndRapoport) vs Cooperator
        # After 15th round (pvalue < alpha) still plays TitForTat.
        # Note it always defects on the last two rounds.
        opponent = axelrod.Cooperator()
        actions = [(C, C)] * 17 + [(D, C)] * 2
        self.versus_test(opponent, expected_actions=actions,
                         attrs={"opponent_is_random": False})

        actions = actions[:-2] + [(C, C)] * 2
        self.versus_test(opponent, expected_actions=actions[:-2],
                         match_attributes={"length": -1},
                         attrs={"opponent_is_random": False})

        # SteinAndRapoport vs Defector
        # After 15th round (p-value < alpha) still plays TitForTat.
        opponent = axelrod.Defector()
        actions = [(C, D)] * 4 + [(D, D)] * 15
        self.versus_test(opponent, expected_actions=actions,
                         attrs={"opponent_is_random": False})

        # SteinAndRapoport vs Alternator
        # After 15th round (p-value > alpha) starts defecting.
        opponent = axelrod.Alternator()
        actions = [(C, C), (C, D), (C, C), (C, D)]

        # On 15th round carry out chi-square test.
        actions += [(D, C), (C, D)] * 5 + [(D, C)]

        # Defect throughout.
        actions += [(D, D), (D, C), (D, D), (D, C)]

        self.versus_test(opponent, expected_actions=actions,
                         attrs={"opponent_is_random": True})

        # The test is carried out again every 15 rounds.
        # If the strategy alternates for the first 12 rounds and then cooperates
        # it is no longer recognised as random.
        opponent = axelrod.MockPlayer([C, D] * 6 + [C] * 50)

        actions = [(C, C), (C, D), (C, C), (C, D)]
        # On 15th round carry out chi-square test.
        actions += [(D, C), (C, D)] * 4 + [(D, C), (C, C), (D, C)]
        # Defect throughout and carry out chi-square test on round 30.
        # Opponent is no longer recognised as random, revert to TFT.
        actions += [(D, C)] * 14 + [(C, C)]
        self.versus_test(opponent, expected_actions=actions,
                         match_attributes={"length": -1},
                         attrs={"opponent_is_random": False})
Example #22
0
    def test_strategy(self):
        actions = [(C, C)] * 100
        self.versus_test(axelrod.Cooperator(), expected_actions=actions)

        actions = [(C, D), (C, D), (D, D), (D, D), (D, D)]
        self.versus_test(axelrod.Defector(),
                         expected_actions=actions,
                         seed=1,
                         attrs={"flack": 15. / 16.})

        actions = [(C, C), (C, D), (C, C), (C, D), (D, C), (C, D)]
        self.versus_test(axelrod.Alternator(),
                         expected_actions=actions,
                         seed=4,
                         attrs={"flack": 5. / 16.})
Example #23
0
    def test_strategy(self):
        """Test that the strategy gives expected behaviour."""
        actions = [(C, C)] + [(D, C)] * 4
        self.versus_test(axelrod.Cooperator(), expected_actions = actions,
                         match_attributes={"length":5}, seed=1)

        # Test that behaviour does not depend on opponent
        actions = [(C, D)] + [(D, D)] * 4
        self.versus_test(axelrod.Defector(), expected_actions = actions,
                         match_attributes={"length":5}, seed=1)

        # Test that behaviour changes when does not know length.
        actions = [(C, C), (C, D), (C, C), (C, D), (C, C)]
        self.versus_test(axelrod.Alternator(), expected_actions = actions,
                         match_attributes={"length":-1}, seed=1)
Example #24
0
 def setUpClass(cls):
     players = [axl.Alternator(), axl.TitForTat()]
     tournament = axl.Tournament(players)
     cls.results = tournament.play()
     cls.data = TournamentResultsSerializer(cls.results).data
     cls.expected_keys = [
         'filename', 'num_interactions', 'players', 'repetitions',
         'nplayers', 'match_lengths', 'wins', 'scores', 'normalised_scores',
         'payoffs', 'score_diffs', 'cooperation', 'normalised_cooperation',
         'initial_cooperation_count', 'good_partner_matrix', 'total_interactions',
         'good_partner_rating', 'ranking', 'ranked_names', 'payoff_matrix',
         'payoff_stddevs', 'payoff_diffs_means', 'vengeful_cooperation',
         'cooperating_rating', 'initial_cooperation_rate', 'eigenjesus_rating',
         'eigenmoses_rating', 'wins',
     ]
Example #25
0
    def test_strategy(self):
        # Test that will forgive one D but will grudge after 2 Ds, randomly
        # forgets count.
        actions = [(C, C), (C, D), (C, C), (C, D), (D, C)]
        self.versus_test(opponent=axelrod.Alternator(),
                         expected_actions=actions,
                         seed=2,
                         attrs={"D_count": 2})

        # Sometime eventually forget count:
        actions = [(C, D), (C, D)] + [(D, D)] * 18 + [(C, D)]
        self.versus_test(opponent=axelrod.Defector(),
                         expected_actions=actions,
                         seed=2,
                         attrs={"D_count": 0})
Example #26
0
    def test_strategy(self):
        R, P, S, T = axelrod.Game().RPST()

        player = self.player(l=R)
        axelrod.seed(0)
        match = axelrod.Match((player, axelrod.Alternator()), turns=200)
        match.play()

        player = self.player(l=P)
        axelrod.seed(0)
        match = axelrod.Match((player, axelrod.Alternator()), turns=200)
        match.play()

        player = self.player(s=1)
        axelrod.seed(0)
        match = axelrod.Match((player, axelrod.Alternator()), turns=200)
        match.play()

        l = 2
        s_min = - min((T - l) / (l - S), (l - S) / (T - l))
        player = self.player(s=s_min, l=2)
        axelrod.seed(0)
        match = axelrod.Match((player, axelrod.Alternator()), turns=200)
        match.play()
Example #27
0
    def test_strategy(self):
        actions = [(C, C)] * 100
        self.versus_test(axelrod.Cooperator(), expected_actions=actions)

        actions = [(C, D)] + [(D, D)] * 8
        self.versus_test(axelrod.Defector(), expected_actions=actions, attrs={"score_to_beat_inc": 5})

        actions = [(C, D)] + [(D, D)] * 8
        # On tenth turn, try a fresh start
        actions += [(C, D), (C, D)] + [(D, D)] * 2
        self.versus_test(axelrod.Defector(), expected_actions=actions, attrs={"last_fresh_start": 11})

        actions = [(C, C), (C, D)]
        # Scores and score_to_beat variables are a turn behind
        self.versus_test(axelrod.Alternator(), expected_actions=actions,
                         attrs={"current_score": 3, "opponent_score": 3, "score_to_beat": 0, "score_to_beat_inc": 0})
        actions += [(D, C), (C, D)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions,
                         attrs={"current_score": 8, "opponent_score": 8, "score_to_beat": 0, "score_to_beat_inc": 5})
        actions += [(D, C), (D, D)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions,
                         attrs={"current_score": 13, "opponent_score": 13, "score_to_beat": 5, "score_to_beat_inc": 10})
        actions += [(D, C), (D, D)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions,
                         attrs={"current_score": 19, "opponent_score": 14, "score_to_beat": 15, "score_to_beat_inc": 15})
        actions += [(D, C), (D, D)]
        self.versus_test(axelrod.Alternator(), expected_actions=actions,
                         attrs={"current_score": 25, "opponent_score": 15, "score_to_beat": 30, "score_to_beat_inc": 20})

        # Build an opponent who will cause us to consider a Fresh Start, but
        # will fail the binomial test.
        opponent_actions = [C] * 5 + [D] * 5
        C5D5_Player = axelrod.MockPlayer(actions=opponent_actions)
        actions = [(C, C)] * 5 + [(C, D)] + [(D, D)] * 3
        actions += [(D, D)] # No Defection here means no Fresh Start.
        self.versus_test(C5D5_Player, expected_actions=actions)
Example #28
0
    def test_strategies_without_countermeasures_return_their_strategy(self):
        tft = axl.TitForTat()
        inspector = axl.Alternator()
        match = axl.Match((tft, inspector), turns=1)
        match.play()
        self.assertEqual(tft.history, [C])
        self.assertEqual(inspect_strategy(inspector=inspector, opponent=tft),
                         C)

        match = axl.Match((tft, inspector), turns=2)
        match.play()
        self.assertEqual(tft.history, [C, C])
        self.assertEqual(inspect_strategy(inspector=inspector, opponent=tft),
                         D)
        self.assertEqual(tft.strategy(inspector), D)
Example #29
0
    def test_strategy(self):
        opponent = axelrod.Alternator()
        actions = [(C, C), (C, D), (D, C)]
        self.versus_test(
            opponent=opponent,
            expected_actions=actions,
            attrs={
                "grudged": True,
                "grudge_memory": 0
            },
        )

        opponent = axelrod.MockPlayer([C, D] + [C] * 10)
        actions = [(C, C), (C, D)] + [(D, C)] * 11
        self.versus_test(
            opponent=opponent,
            expected_actions=actions,
            attrs={
                "grudged": True,
                "grudge_memory": 10
            },
        )

        # Eventually the grudge is dropped
        opponent = axelrod.MockPlayer([C, D] + [C] * 10)
        actions = [(C, C), (C, D)] + [(D, C)] * 11 + [(C, D)]
        self.versus_test(
            opponent=opponent,
            expected_actions=actions,
            attrs={
                "grudged": False,
                "grudge_memory": 0,
                "mem_length": 10
            },
        )

        # Grudged again on opponent's D
        opponent = axelrod.MockPlayer([C, D] + [C] * 11)
        actions = [(C, C), (C, D)] + [(D, C)] * 11 + [(C, C), (C, D), (D, C)]
        self.versus_test(
            opponent=opponent,
            expected_actions=actions,
            attrs={
                "grudged": True,
                "grudge_memory": 0,
                "mem_length": 2
            },
        )
 def test_play_single_interaction(self):
     players = [
         axelrod.Alternator(),
         axelrod.Defector(),
         axelrod.TitForTat()
     ]
     rr = axelrod.RoundRobin(players=players, game=self.game, turns=20)
     player1 = players[0]
     player2 = players[2]
     classes = (player1.__class__, player2.__class__)
     scores, cooperation_rates = (rr._play_single_interaction(
         player1, player2, classes))
     expected_scores = (53, 48)
     expected_cooperation_rates = (10, 11)
     self.assertEqual(expected_scores, scores)
     self.assertEqual(expected_cooperation_rates, cooperation_rates)