def test_copy(self): pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] cache = LruCache(pairs) self.assertEqual(cache.copy().items(), cache.items()) self.assertEqual(cache.copy().keys(), cache.keys()) self.assertEqual(LruCache().items(), LruCache().copy().items()) self.assertEqual(LruCache().keys(), LruCache().copy().keys())
def test_getitem(self): pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] cache = LruCache(pairs) with self.assertRaises(KeyError): LruCache()['key'] with self.assertRaises(KeyError): cache['key'] for key, value in pairs: self.assertEqual(value, cache[key])
def test_eq(self): pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] cache = LruCache(pairs) self.assertTrue(cache == cache) self.assertTrue(LruCache() == LruCache()) self.assertTrue(LruCache(pairs) == LruCache(pairs)) self.assertFalse(LruCache() == list()) self.assertFalse(LruCache(pairs) == LruCache(pairs[1:])) self.assertFalse(LruCache(pairs) == LruCache(pairs[::-1]))
def test_lock(self, RLockMock): lock = RLockMock() cache = LruCache() lock.__enter__.assert_not_called() lock.__exit__.assert_not_called() cache = LruCache(expires=10) lock.__enter__.assert_called() lock.__exit__.assert_called()
def test_get_item(self): """Test getting item from cache.""" cache = LruCache(3) cache['k1'] = 100 self.assertEqual(cache['k1'], 100)
def test_delitem(self): with self.assertRaises(KeyError): del LruCache()['key'] pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] cache = LruCache(pairs) with self.assertRaises(KeyError): del cache['key'] for index, (key, value) in enumerate(pairs): del cache[key] self.assertEqual(cache.items(), pairs[index+1:][::-1]) # start deleting from the tail cache.update(pairs) for index, (key, value) in enumerate(pairs[::-1]): del cache[key] index = len(pairs) - index - 1 self.assertEqual(cache.items(), pairs[:index][::-1])
def test_len(self): pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] cache = LruCache(pairs) self.assertEqual(len(pairs), len(cache)) del cache['a'] self.assertEqual(len(pairs) - 1, len(cache)) cache.clear() self.assertEqual(len(cache), 0)
def test_setitem(self): with self.assertRaises(ValueError): LruCache()['a'] = None with self.assertRaises(ValueError): LruCache()[None] = 'a' with self.assertRaises(ValueError): LruCache()[None] = None cache = LruCache(capacity=10) cache['a'] = 1 cache['b'] = 2 self.assertEqual(cache.items(), [('b', 2), ('a', 1)]) cache['a'] = 3 self.assertEqual(cache.items(), [('a', 3), ('b', 2)]) cache['b'] = 4 self.assertEqual(cache.items(), [('b', 4), ('a', 3)]) cache['c'] = 5 self.assertEqual(cache.items(), [('c', 5), ('b', 4), ('a', 3)]) del cache['c'] cache['c'] = 5 self.assertEqual(cache.items(), [('c', 5), ('b', 4), ('a', 3)])
def test_set_item(self): """Test putting item in cache.""" cache = LruCache(3) cache['k1'] = 100 cache['k2'] = 200 cache['k3'] = 300 cache['k4'] = 400 self.assertEqual(len(cache), 3) self.assertListEqual(list(cache.items()), [('k2', 200), ('k3', 300), ('k4', 400)])
def test_clear(self): pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] cache = LruCache(pairs) self.assertEqual(len(cache), len(pairs)) cache.clear() self.assertEqual(len(cache), 0) cache.clear() self.assertEqual(len(cache), 0) cache.update(pairs) self.assertEqual(len(cache), len(pairs)) cache.clear() self.assertEqual(len(cache), 0)
def __init__(self, pgdatadir, catalog_class): self.pgdatadir = pgdatadir self.catalog_class = catalog_class ctrlfile = ControlFile(pgdatadir) self.blocksz = ctrlfile.blcksz self.segfilesz = ctrlfile.relseg_size self.catalog_version_no = ctrlfile.catalog_version_no self.pg_majorversion = catalog_class.loadpgversion(pgdatadir) self.heapbuffer = LruCache(HeapBufferPage, self.blocksz, HEAP_BUFFER_COUNT)
def do_size(self, line): """size n - sets the maximum size of the cache to n objects""" if self.cache == None: args = line.split() if len(args) != 1: print "Syntax Error. Expected 1 arguments, got %d" % len(args) return False self.cache = LruCache(int(args[0])) print("SIZE OK") else: print("ERROR")
def test_update_item(self): """Test update item in cache.""" cache = LruCache(3) cache['k1'] = 100 cache['k2'] = 200 cache['k1'] = 300 self.assertEqual(len(cache), 2) self.assertListEqual(list(cache.items()), [ ('k2', 200), ('k1', 300), ])
def lru_cache(maxsize=128, expires=10*60): """ A memoized function, backed by an LRU cache. Supports data expiration. >>> @lru_cache(maxsize=2, expires=10) ... def function(x): ... print "function(" + str(x) + ")" ... return x >>> f(3) function(3) 3 >>> f(5) function(5) 5 >>> f(3) # the item hasn't expired yet, the wrapped function won't be invoked 3 >>> f(5) # the item hasn't expired yet, the wrapped function won't be invoked 5 >>> import time >>> time.sleep(3) # enough time to remove the first item (3) from the cache >>> f(3) # since there is no such item in cache, execute the function again function(3) 3 >>> time.sleep(2) # enough time to remove the other item (5) from the cache >>> f(5) # same thing for 5 function(5) 5 >>> f(3) 3 >>> f(4) # the underlying LRU cache will replace 4 with 5 function(4) 4 >>> f(5) function(5) 5 """ # create a single cache per function that is being decorated cache = LruCache(capacity=maxsize, expires=expires) def _lru(function): @wraps(function) def _lru_wrapper(*args, **kwargs): # generate the key key = _get_key(function, args, kwargs) if key in cache: return cache[key] result = function(*args, **kwargs) cache[key] = result return result return _lru_wrapper return _lru
def test_delete(self, create_mock, CleanManagerMock, RLockMock): cleanManager = CleanManagerMock() lock = RLockMock() node = _ExpNode(key='a', value='b', expires=10) create_mock.return_value = node cache = LruCache() cache.add('a', 'b', expires=10) del cache['a'] cleanManager.add.assert_called_with(node) cleanManager.on_delete.assert_called() lock.__enter__.assert_called() lock.__exit__.assert_called()
def test_contains(self): self.assertFalse('a' in LruCache()) self.assertFalse('a' in LruCache([('b', 2), ('c', 3), ('d', 4)])) self.assertTrue('b' in LruCache([('b', 2), ('c', 3), ('d', 4)])) self.assertTrue('b' not in LruCache()) self.assertTrue('b' not in LruCache([('c', 3), ('d', 4)])) cache = LruCache([('b', 2), ('c', 3), ('d', 4)]) self.assertTrue('a' not in cache) cache['a'] = 3 self.assertTrue('a' in cache)
def lru_cache(maxsize=128, expires=10 * 60): cache = LruCache(capacity=maxsize, expires=expires) def _lru(function): @wraps(function) def _lru_wrapper(*args, **kwargs): key = _get_key(function, args, kwargs) if key in cache: return cache[key] result = function(*args, **kwargs) cache[key] = result return result return _lru_wrapper return _lru
def test_init(self): with self.assertRaises(ValueError): LruCache(capacity=0) pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] self.assertEqual(sorted(LruCache(pairs).items()), pairs) self.assertEqual(sorted(LruCache(dict(pairs)).items()), pairs) self.assertEqual(sorted(LruCache(**dict(pairs)).items()), pairs) self.assertEqual(sorted(LruCache(pairs, e=4, f=5, r=6).items()), pairs + [('e', 4), ('f', 5), ('r', 6)]) cache = LruCache(pairs) cache.__init__([('e', 5), ('t', 6)]) self.assertEqual(sorted(cache.items()), pairs + [('e', 5), ('t', 6)])
def test_iter(self): pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] values = [value for key, value in pairs][::-1] cache = LruCache(pairs) self.assertEqual(list(iter(cache)), values)
def test_get_non_existed_item(self): """Test getting non-existed item from cache.""" cache = LruCache(3) with self.assertRaises(KeyError): cache['k1']
def test_repr(self): pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] cache = LruCache(pairs) self.assertEqual(repr(cache), _get_printable(pairs[::-1])) self.assertEqual(repr(LruCache()), '{}')
def __init__(self, datadir, pageclass, buffsz): self.datadir = datadir ctrlfile = ControlFile(datadir) self.blcksz = ctrlfile.blcksz self.buffer = LruCache(pageclass, self.blcksz, buffsz)