| 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) |
