def test_save(self):
cache = DeterministicCache()
cache[self.test_key] = self.test_value
cache.save(self.test_save_file)
with open(self.test_save_file, 'rb') as f:
text = f.read()
self.assertEqual(text, self.test_pickle)
def test_save(self):
cache = DeterministicCache()
cache[self.test_key] = self.test_value
cache.save(self.test_save_file)
with open(self.test_save_file, 'rb') as f:
text = f.read()
self.assertEqual(text, self.test_pickle)
def test_load_error_for_inccorect_format(self):
tmp_file = tempfile.NamedTemporaryFile()
with open(tmp_file.name, 'wb') as io:
pickle.dump(range(5), io)
with self.assertRaises(ValueError):
cache = DeterministicCache()
cache.load(tmp_file.name)
def test_load_error_for_inccorect_format(self):
tmp_file = tempfile.NamedTemporaryFile()
with open(tmp_file.name, 'wb') as io:
pickle.dump(range(5), io)
with self.assertRaises(ValueError):
cache = DeterministicCache()
cache.load(tmp_file.name)
def test_load_error_for_inccorect_format(self):
filename = "test_outputs/test.cache"
with open(filename, 'wb') as io:
pickle.dump(range(5), io)
with self.assertRaises(ValueError):
cache = DeterministicCache()
cache.load(filename)
def test_load_error_for_inccorect_format(self):
filename = "test_outputs/test.cache"
with open(filename, 'wb') as io:
pickle.dump(range(5), io)
with self.assertRaises(ValueError):
cache = DeterministicCache()
cache.load(filename)
def __init__(self):
global ROUNDS
global PLAYERS
self.result = []
self.game = Game()
self.turns = ROUNDS
self.players = list(PLAYERS)
self._cache = DeterministicCache()
def test_is_valid_key(self):
cache = DeterministicCache()
self.assertTrue(cache._is_valid_key(self.test_key))
# Should return false if key is not a tuple
self.assertFalse(cache._is_valid_key('test'))
# Should return false if tuple is not a triplet
self.assertFalse(cache._is_valid_key(('test', 'test')))
# Should return false if contents of tuple are not axelrod Players
# and an integer
self.assertFalse(cache._is_valid_key(('test', 'test', 'test')))
self.assertFalse(cache._is_valid_key((TitForTat, 'test', 2)))
self.assertFalse(cache._is_valid_key(('test', TitForTat, 2)))
self.assertFalse(cache._is_valid_key(
(TitForTat, TitForTat, TitForTat)))
# Should return false if either player class is stochastic
self.assertFalse(cache._is_valid_key((Random, TitForTat, 2)))
self.assertFalse(cache._is_valid_key((TitForTat, Random, 2)))
def test_is_valid_key(self):
cache = DeterministicCache()
self.assertTrue(cache._is_valid_key(self.test_key))
# Should return false if key is not a tuple
self.assertFalse(cache._is_valid_key('test'))
# Should return false if tuple is not a triplet
self.assertFalse(cache._is_valid_key(('test', 'test')))
# Should return false if contents of tuple are not axelrod Players
# and an integer
self.assertFalse(cache._is_valid_key(('test', 'test', 'test')))
self.assertFalse(cache._is_valid_key((TitForTat, 'test', 2)))
self.assertFalse(cache._is_valid_key(('test', TitForTat, 2)))
self.assertFalse(cache._is_valid_key((TitForTat, TitForTat, TitForTat)))
# Should return false if either player class is stochastic
self.assertFalse(cache._is_valid_key((Random, TitForTat, 2)))
self.assertFalse(cache._is_valid_key((TitForTat, Random, 2)))
def test_set_immutable_cache(self):
cache = DeterministicCache()
cache.mutable = False
with self.assertRaises(ValueError):
cache[self.test_key] = self.test_value
def setUp(self):
self.cache = DeterministicCache()
def test_set_immutable_cache(self):
cache = DeterministicCache()
cache.mutable = False
with self.assertRaises(ValueError):
cache[self.test_key] = self.test_value
def setUp(self):
self.cache = DeterministicCache()
def test_load(self):
cache = DeterministicCache()
cache.load(self.test_load_file)
self.assertEqual(cache[self.test_key], self.test_value)
def test_del_item(self):
cache = DeterministicCache()
cache[self.test_key] = self.test_value
self.assertTrue(self.test_key in cache)
del cache[self.test_key]
self.assertFalse(self.test_key in cache)
def test_is_valid_value(self):
cache = DeterministicCache()
self.assertTrue(cache._is_valid_value(self.test_value))
# Should return false if value is not a list
self.assertFalse(cache._is_valid_value('test'))
def test_basic_init(self):
cache = DeterministicCache()
self.assertTrue(cache.mutable)
def test_is_valid_value(self):
cache = DeterministicCache()
self.assertTrue(cache._is_valid_value(self.test_value))
# Should return false if value is not a list
self.assertFalse(cache._is_valid_value('test'))
def test_load(self):
cache = DeterministicCache()
cache.load(self.test_load_file)
self.assertEqual(cache[self.test_key], self.test_value)
def test_setitem(self):
cache = DeterministicCache()
cache[self.test_key] = self.test_value
self.assertEqual(cache[self.test_key], self.test_value)
def test_init_from_file(self):
cache = DeterministicCache(file_name=self.test_load_file)
self.assertEqual(cache[self.test_key], self.test_value)
def test_setitem_invalid_key(self):
cache = DeterministicCache()
invalid_key = (1, 2, 3, 4)
with self.assertRaises(ValueError):
cache[invalid_key] = 3
class TestDeterministicCache(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.test_key = (TitForTat(), Defector())
cls.test_value = [(C, D), (D, D), (D, D)]
cls.test_save_file = "test_cache_save.txt"
cls.test_load_file = "test_cache_load.txt"
test_data_to_pickle = {("Tit For Tat", "Defector"): [(C, D), (D, D), (D, D)]}
cls.test_pickle = pickle.dumps(test_data_to_pickle)
with open(cls.test_load_file, "wb") as f:
f.write(cls.test_pickle)
@classmethod
def tearDownClass(cls):
os.remove(cls.test_save_file)
os.remove(cls.test_load_file)
def setUp(self):
self.cache = DeterministicCache()
def test_basic_init(self):
self.assertTrue(self.cache.mutable)
def test_init_from_file(self):
loaded_cache = DeterministicCache(file_name=self.test_load_file)
self.assertEqual(loaded_cache[self.test_key], self.test_value)
def test_setitem(self):
self.cache[self.test_key] = self.test_value
self.assertEqual(self.cache[self.test_key], self.test_value)
def test_setitem_invalid_key_not_tuple(self):
invalid_key = "test"
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_key_first_two_elements_not_player(self):
invalid_key = ("test", "test")
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
invalid_key = (TitForTat(), "test")
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
invalid_key = ("test", TitForTat())
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_key_too_many_players(self):
invalid_key = (TitForTat(), TitForTat(), TitForTat())
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_key_stochastic_player(self):
invalid_key = (Random(), TitForTat())
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
invalid_key = (TitForTat(), Random())
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_value_not_list(self):
with self.assertRaises(ValueError):
self.cache[self.test_key] = 5
def test_setitem_with_immutable_cache(self):
self.cache.mutable = False
with self.assertRaises(ValueError):
self.cache[self.test_key] = self.test_value
def test_save(self):
self.cache[self.test_key] = self.test_value
self.cache.save(self.test_save_file)
with open(self.test_save_file, "rb") as f:
text = f.read()
self.assertEqual(text, self.test_pickle)
def test_load(self):
self.cache.load(self.test_load_file)
self.assertEqual(self.cache[self.test_key], self.test_value)
def test_load_error_for_inccorect_format(self):
filename = "test_outputs/test.cache"
with open(filename, "wb") as io:
pickle.dump(range(5), io)
with self.assertRaises(ValueError):
self.cache.load(filename)
def test_del_item(self):
self.cache[self.test_key] = self.test_value
self.assertTrue(self.test_key in self.cache)
del self.cache[self.test_key]
self.assertFalse(self.test_key in self.cache)
def test_setitem_invalid_value(self):
cache = DeterministicCache()
with self.assertRaises(ValueError):
cache[self.test_key] = 5
class TestDeterministicCache(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.test_key = (TitForTat(), Defector(), 3)
cls.test_value = [(C, D), (D, D), (D, D)]
cls.test_save_file = "test_cache_save.txt"
cls.test_load_file = "test_cache_load.txt"
test_data_to_pickle = {
("Tit For Tat", "Defector", 3): [(C, D), (D, D), (D, D)]
}
cls.test_pickle = pickle.dumps(test_data_to_pickle)
with open(cls.test_load_file, "wb") as f:
f.write(cls.test_pickle)
@classmethod
def tearDownClass(cls):
os.remove(cls.test_save_file)
os.remove(cls.test_load_file)
def setUp(self):
self.cache = DeterministicCache()
def test_basic_init(self):
self.assertTrue(self.cache.mutable)
def test_init_from_file(self):
loaded_cache = DeterministicCache(file_name=self.test_load_file)
self.assertEqual(loaded_cache[self.test_key], self.test_value)
def test_setitem(self):
self.cache[self.test_key] = self.test_value
self.assertEqual(self.cache[self.test_key], self.test_value)
def test_setitem_invalid_key_not_tuple(self):
invalid_key = "test"
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_key_too_short(self):
invalid_key = self.test_key + (4, )
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_key_too_long(self):
invalid_key = self.test_key[:2]
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_key_first_two_elements_not_player(self):
invalid_key = ("test", "test", 2)
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
invalid_key = (TitForTat(), "test", 2)
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
invalid_key = ("test", TitForTat(), 2)
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_key_last_element_not_integer(self):
invalid_key = (TitForTat(), TitForTat(), TitForTat())
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_key_stochastic_player(self):
invalid_key = (Random(), TitForTat(), 2)
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
invalid_key = (TitForTat(), Random(), 2)
with self.assertRaises(ValueError):
self.cache[invalid_key] = self.test_value
def test_setitem_invalid_value_not_list(self):
with self.assertRaises(ValueError):
self.cache[self.test_key] = 5
def test_setitem_with_immutable_cache(self):
self.cache.mutable = False
with self.assertRaises(ValueError):
self.cache[self.test_key] = self.test_value
def test_save(self):
self.cache[self.test_key] = self.test_value
self.cache.save(self.test_save_file)
with open(self.test_save_file, "rb") as f:
text = f.read()
self.assertEqual(text, self.test_pickle)
def test_load(self):
self.cache.load(self.test_load_file)
self.assertEqual(self.cache[self.test_key], self.test_value)
def test_load_error_for_inccorect_format(self):
filename = "test_outputs/test.cache"
with open(filename, "wb") as io:
pickle.dump(range(5), io)
with self.assertRaises(ValueError):
self.cache.load(filename)
def test_del_item(self):
self.cache[self.test_key] = self.test_value
self.assertTrue(self.test_key in self.cache)
del self.cache[self.test_key]
self.assertFalse(self.test_key in self.cache)
