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)
