Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

worse and worse refactor new testing framework #927

Merged
merged 7 commits into from Mar 25, 2017
Merged

worse and worse refactor new testing framework #927

Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
1e62e64
worse and worse refactor new testing framework
Mar 24, 2017
d744d2e
Delete test_worse_and_worse.py
Mar 24, 2017
7806580
Rename test_worse_and_worse_v1.py to test_worse_and_worse.py
Mar 24, 2017
deb0c2b
Update test_worse_and_worse.py
Mar 24, 2017
40b3685
Merge pull request #1 from alajara/alajara-patch-1
Mar 24, 2017
9c42a4a
Update test_worse_and_worse.py
Mar 24, 2017
b1fc5d2
Merge pull request #2 from alajara/alajara-patch-2
Mar 24, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
108 changes: 54 additions & 54 deletions axelrod/tests/strategies/test_worse_and_worse.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,6 @@

C, D = axelrod.Actions.C, axelrod.Actions.D


class TestWorseAndWorse(TestPlayer):

name = "Worse and Worse"
Expand All @@ -19,14 +18,22 @@ class TestWorseAndWorse(TestPlayer):
'manipulates_source': False,
'manipulates_state': False
}

def test_strategy(self):
"""Test that the strategy gives expected behaviour."""
self.first_play_test(C)
self.responses_test([C] * 6 + [D] + [C] * 3, seed=8)
self.responses_test([C] * 4 + [D] + [C] * 3, [C, C], [D, D], seed=8)

# 6 Rounds Cooperate given seed
actions = [(C, C)] * 6 + [(D, C)] + [(C, C)] * 3
self.versus_test(axelrod.Cooperator(), expected_actions = actions,
seed=8)

# 6 Rounds Cooperate and Defect no matter oponent
actions = [(C, D)] * 6 + [(D, D)] + [(C, D)] * 3
self.versus_test(axelrod.Defector(), expected_actions = actions,
seed=8)


class TestWorseAndWorseRandom(TestPlayer):

name = "Knowledgeable Worse and Worse"
Expand All @@ -44,42 +51,22 @@ class TestWorseAndWorseRandom(TestPlayer):
def test_strategy(self):
"""Test that the strategy gives expected behaviour."""
self.first_play_test(C)
# self.responses_test([C] + [D] * 4, seed=1)
# self.responses_test([C] * 4 + [D] + [C] * 3, [C, C],
# [D, D], seed=1)

axelrod.seed(1)
opponent = axelrod.Cooperator()
player = axelrod.KnowledgeableWorseAndWorse()
match = axelrod.Match((opponent, player), turns=5)
self.assertEqual(match.play(), [('C', 'C'),
('C', 'D'),
('C', 'D'),
('C', 'D'),
('C', 'D')])

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
opponent = axelrod.Defector()
player = axelrod.KnowledgeableWorseAndWorse()
axelrod.seed(1)
match = axelrod.Match((opponent, player), turns=5)
self.assertEqual(match.play(), [('D', 'C'),
('D', 'D'),
('D', 'D'),
('D', 'D'),
('D', 'D')])

# Test that behaviour changes when does not know length.
axelrod.seed(1)
match = axelrod.Match((opponent, player), turns=5,
match_attributes={'length': float('inf')})
self.assertEqual(match.play(), [('D', 'C'),
('D', 'C'),
('D', 'C'),
('D', 'C'),
('D', 'C')])
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)


class TestWorseAndWorse2(TestPlayer):

name = "Worse and Worse 2"
Expand All @@ -96,20 +83,29 @@ class TestWorseAndWorse2(TestPlayer):

def test_strategy(self):
"""Test that the strategy gives expected behaviour."""

# Test that first move is C
self.first_play_test('C')
# Test that given a history, next move matches opponent (round <= 20)
self.responses_test([C], [C], [C])
self.responses_test([D], [C, C], [C, D])
self.responses_test([C], [C] * 19, [C] * 19)
self.responses_test([D], [C] * 19, [C] * 18 + [D])
# Test that after round 20, strategy follows stochastic behaviour given
# a seed
self.responses_test([C, D, C, C, C, C, D, C, C, C], [C] * 20, [C] * 20,
seed=8)
self.responses_test([D, D, C, C, D, C, C, C, C, C], [C] * 20, [C] * 20,
seed=2)
self.first_play_test(C)

# Test next move matches opponent
actions = [(C, C)] * 19
self.versus_test(axelrod.Cooperator(), expected_actions = actions)

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

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

# After round 20, strategy follows stochastic behavior given a seed
actions = [(C, C)] * 20 + [(C, D), (D, C), (C, C), (C, D)]
self.versus_test(opponent=axelrod.MockPlayer([C] * 20 + [D, C, C, D]), expected_actions = actions,
seed=8)

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


class TestWorseAndWorse3(TestPlayer):

Expand All @@ -127,15 +123,19 @@ class TestWorseAndWorse3(TestPlayer):

def test_strategy(self):
"""Test that the strategy gives expected behaviour."""

# Test that first move is C
self.first_play_test(C)

# Test that if opponent only defects, strategy also defects
self.responses_test([D], [D] * 5, [D] * 5)
actions = [(C, D)] + [(D, D)] * 4
self.versus_test(axelrod.Defector(), expected_actions=actions)

# Test that if opponent only cooperates, strategy also cooperates
self.responses_test([C], [C] * 5, [C] * 5)
actions = [(C, C)] * 5
self.versus_test(axelrod.Cooperator(), expected_actions=actions)

# Test that given a non 0/1 probability of defecting, strategy follows
# stochastic behaviour, given a seed
self.responses_test([D, C, C, D, C, C, C, C, C, C], [C] * 5,
[C, D, C, D, C], seed=8)
self.responses_test([D, D, D, C, C, D, D, D, C, C], [C] * 5, [D] * 5,
seed=2)
actions = [(C, C), (C, D), (C, C), (D, D), (C, C), (D, C)]
self.versus_test(axelrod.MockPlayer([C,D,C,D,C]), expected_actions=actions, seed=8)