305 lines
9.6 KiB
Python
305 lines
9.6 KiB
Python
import sys
|
|
import unittest
|
|
|
|
|
|
class CacheTestMixin:
|
|
|
|
Cache = None
|
|
|
|
def test_defaults(self):
|
|
cache = self.Cache(maxsize=1)
|
|
self.assertEqual(0, len(cache))
|
|
self.assertEqual(1, cache.maxsize)
|
|
self.assertEqual(0, cache.currsize)
|
|
self.assertEqual(1, cache.getsizeof(None))
|
|
self.assertEqual(1, cache.getsizeof(""))
|
|
self.assertEqual(1, cache.getsizeof(0))
|
|
self.assertTrue(repr(cache).startswith(cache.__class__.__name__))
|
|
|
|
def test_insert(self):
|
|
cache = self.Cache(maxsize=2)
|
|
|
|
cache.update({1: 1, 2: 2})
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(2, cache[2])
|
|
|
|
cache[3] = 3
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(3, cache[3])
|
|
self.assertTrue(1 in cache or 2 in cache)
|
|
|
|
cache[4] = 4
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(4, cache[4])
|
|
self.assertTrue(1 in cache or 2 in cache or 3 in cache)
|
|
|
|
def test_update(self):
|
|
cache = self.Cache(maxsize=2)
|
|
|
|
cache.update({1: 1, 2: 2})
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(2, cache[2])
|
|
|
|
cache.update({1: 1, 2: 2})
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(2, cache[2])
|
|
|
|
cache.update({1: "a", 2: "b"})
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual("a", cache[1])
|
|
self.assertEqual("b", cache[2])
|
|
|
|
def test_delete(self):
|
|
cache = self.Cache(maxsize=2)
|
|
|
|
cache.update({1: 1, 2: 2})
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(2, cache[2])
|
|
|
|
del cache[2]
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(1, cache[1])
|
|
self.assertNotIn(2, cache)
|
|
|
|
del cache[1]
|
|
self.assertEqual(0, len(cache))
|
|
self.assertNotIn(1, cache)
|
|
self.assertNotIn(2, cache)
|
|
|
|
with self.assertRaises(KeyError):
|
|
del cache[1]
|
|
self.assertEqual(0, len(cache))
|
|
self.assertNotIn(1, cache)
|
|
self.assertNotIn(2, cache)
|
|
|
|
def test_pop(self):
|
|
cache = self.Cache(maxsize=2)
|
|
|
|
cache.update({1: 1, 2: 2})
|
|
self.assertEqual(2, cache.pop(2))
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(1, cache.pop(1))
|
|
self.assertEqual(0, len(cache))
|
|
|
|
with self.assertRaises(KeyError):
|
|
cache.pop(2)
|
|
with self.assertRaises(KeyError):
|
|
cache.pop(1)
|
|
with self.assertRaises(KeyError):
|
|
cache.pop(0)
|
|
|
|
self.assertEqual(None, cache.pop(2, None))
|
|
self.assertEqual(None, cache.pop(1, None))
|
|
self.assertEqual(None, cache.pop(0, None))
|
|
|
|
def test_popitem(self):
|
|
cache = self.Cache(maxsize=2)
|
|
|
|
cache.update({1: 1, 2: 2})
|
|
self.assertIn(cache.pop(1), {1: 1, 2: 2})
|
|
self.assertEqual(1, len(cache))
|
|
self.assertIn(cache.pop(2), {1: 1, 2: 2})
|
|
self.assertEqual(0, len(cache))
|
|
|
|
with self.assertRaises(KeyError):
|
|
cache.popitem()
|
|
|
|
@unittest.skipUnless(sys.version_info >= (3, 7), "requires Python 3.7")
|
|
def test_popitem_exception_context(self):
|
|
# since Python 3.7, MutableMapping.popitem() suppresses
|
|
# exception context as implementation detail
|
|
exception = None
|
|
try:
|
|
self.Cache(maxsize=2).popitem()
|
|
except Exception as e:
|
|
exception = e
|
|
self.assertIsNone(exception.__cause__)
|
|
self.assertTrue(exception.__suppress_context__)
|
|
|
|
def test_missing(self):
|
|
class DefaultCache(self.Cache):
|
|
def __missing__(self, key):
|
|
self[key] = key
|
|
return key
|
|
|
|
cache = DefaultCache(maxsize=2)
|
|
|
|
self.assertEqual(0, cache.currsize)
|
|
self.assertEqual(2, cache.maxsize)
|
|
self.assertEqual(0, len(cache))
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(2, cache[2])
|
|
self.assertEqual(2, len(cache))
|
|
self.assertTrue(1 in cache and 2 in cache)
|
|
|
|
self.assertEqual(3, cache[3])
|
|
self.assertEqual(2, len(cache))
|
|
self.assertTrue(3 in cache)
|
|
self.assertTrue(1 in cache or 2 in cache)
|
|
self.assertTrue(1 not in cache or 2 not in cache)
|
|
|
|
self.assertEqual(4, cache[4])
|
|
self.assertEqual(2, len(cache))
|
|
self.assertTrue(4 in cache)
|
|
self.assertTrue(1 in cache or 2 in cache or 3 in cache)
|
|
|
|
# verify __missing__() is *not* called for any operations
|
|
# besides __getitem__()
|
|
|
|
self.assertEqual(4, cache.get(4))
|
|
self.assertEqual(None, cache.get(5))
|
|
self.assertEqual(5 * 5, cache.get(5, 5 * 5))
|
|
self.assertEqual(2, len(cache))
|
|
|
|
self.assertEqual(4, cache.pop(4))
|
|
with self.assertRaises(KeyError):
|
|
cache.pop(5)
|
|
self.assertEqual(None, cache.pop(5, None))
|
|
self.assertEqual(5 * 5, cache.pop(5, 5 * 5))
|
|
self.assertEqual(1, len(cache))
|
|
|
|
cache.clear()
|
|
cache[1] = 1 + 1
|
|
self.assertEqual(1 + 1, cache.setdefault(1))
|
|
self.assertEqual(1 + 1, cache.setdefault(1, 1))
|
|
self.assertEqual(1 + 1, cache[1])
|
|
self.assertEqual(2 + 2, cache.setdefault(2, 2 + 2))
|
|
self.assertEqual(2 + 2, cache.setdefault(2, None))
|
|
self.assertEqual(2 + 2, cache.setdefault(2))
|
|
self.assertEqual(2 + 2, cache[2])
|
|
self.assertEqual(2, len(cache))
|
|
self.assertTrue(1 in cache and 2 in cache)
|
|
self.assertEqual(None, cache.setdefault(3))
|
|
self.assertEqual(2, len(cache))
|
|
self.assertTrue(3 in cache)
|
|
self.assertTrue(1 in cache or 2 in cache)
|
|
self.assertTrue(1 not in cache or 2 not in cache)
|
|
|
|
def test_missing_getsizeof(self):
|
|
class DefaultCache(self.Cache):
|
|
def __missing__(self, key):
|
|
try:
|
|
self[key] = key
|
|
except ValueError:
|
|
pass # not stored
|
|
return key
|
|
|
|
cache = DefaultCache(maxsize=2, getsizeof=lambda x: x)
|
|
|
|
self.assertEqual(0, cache.currsize)
|
|
self.assertEqual(2, cache.maxsize)
|
|
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(1, cache.currsize)
|
|
self.assertIn(1, cache)
|
|
|
|
self.assertEqual(2, cache[2])
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(2, cache.currsize)
|
|
self.assertNotIn(1, cache)
|
|
self.assertIn(2, cache)
|
|
|
|
self.assertEqual(3, cache[3]) # not stored
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(2, cache.currsize)
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(1, cache.currsize)
|
|
self.assertEqual((1, 1), cache.popitem())
|
|
|
|
def _test_getsizeof(self, cache):
|
|
self.assertEqual(0, cache.currsize)
|
|
self.assertEqual(3, cache.maxsize)
|
|
self.assertEqual(1, cache.getsizeof(1))
|
|
self.assertEqual(2, cache.getsizeof(2))
|
|
self.assertEqual(3, cache.getsizeof(3))
|
|
|
|
cache.update({1: 1, 2: 2})
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(3, cache.currsize)
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(2, cache[2])
|
|
|
|
cache[1] = 2
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(2, cache.currsize)
|
|
self.assertEqual(2, cache[1])
|
|
self.assertNotIn(2, cache)
|
|
|
|
cache.update({1: 1, 2: 2})
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(3, cache.currsize)
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(2, cache[2])
|
|
|
|
cache[3] = 3
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(3, cache.currsize)
|
|
self.assertEqual(3, cache[3])
|
|
self.assertNotIn(1, cache)
|
|
self.assertNotIn(2, cache)
|
|
|
|
with self.assertRaises(ValueError):
|
|
cache[3] = 4
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(3, cache.currsize)
|
|
self.assertEqual(3, cache[3])
|
|
|
|
with self.assertRaises(ValueError):
|
|
cache[4] = 4
|
|
self.assertEqual(1, len(cache))
|
|
self.assertEqual(3, cache.currsize)
|
|
self.assertEqual(3, cache[3])
|
|
|
|
def test_getsizeof_param(self):
|
|
self._test_getsizeof(self.Cache(maxsize=3, getsizeof=lambda x: x))
|
|
|
|
def test_getsizeof_subclass(self):
|
|
class Cache(self.Cache):
|
|
def getsizeof(self, value):
|
|
return value
|
|
|
|
self._test_getsizeof(Cache(maxsize=3))
|
|
|
|
def test_pickle(self):
|
|
import pickle
|
|
|
|
source = self.Cache(maxsize=2)
|
|
source.update({1: 1, 2: 2})
|
|
|
|
cache = pickle.loads(pickle.dumps(source))
|
|
self.assertEqual(source, cache)
|
|
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(1, cache[1])
|
|
self.assertEqual(2, cache[2])
|
|
|
|
cache[3] = 3
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(3, cache[3])
|
|
self.assertTrue(1 in cache or 2 in cache)
|
|
|
|
cache[4] = 4
|
|
self.assertEqual(2, len(cache))
|
|
self.assertEqual(4, cache[4])
|
|
self.assertTrue(1 in cache or 2 in cache or 3 in cache)
|
|
|
|
self.assertEqual(cache, pickle.loads(pickle.dumps(cache)))
|
|
|
|
def test_pickle_maxsize(self):
|
|
import pickle
|
|
import sys
|
|
|
|
# test empty cache, single element, large cache (recursion limit)
|
|
for n in [0, 1, sys.getrecursionlimit() * 2]:
|
|
source = self.Cache(maxsize=n)
|
|
source.update((i, i) for i in range(n))
|
|
cache = pickle.loads(pickle.dumps(source))
|
|
self.assertEqual(n, len(cache))
|
|
self.assertEqual(source, cache)
|