class MyTestCase(unittest.TestCase):
def setUp(self):
self.cache = LRUCache(4)
def test_set_get(self):
self.cache.set('Jesse', 'James')
self.assertTrue(self.cache.get('Jesse'), 'James')
def test_delete(self):
self.cache.set('Jesse', 'James')
self.cache.get('Jesse')
self.cache.delete('Walter')
def test_out_of_memory(self):
self.cache.set('Jesse', 'James')
self.cache.set('Jim', 'Richard')
self.cache.set('Smith', 'Alex')
self.cache.set('Walter', 'White')
self.cache.set(
'Jesse',
'John') # ('Jesse', 'John') will be moved to the end of the list
self.cache.set('Williams',
'Jack') # ('Jim', 'Richard') will be deleted
self.assertEqual(self.cache.get('Jim'), None)
self.assertEqual(self.cache.get('Smith'), 'Alex')
self.cache.set('Jim', 'Richard') # ('Walter', 'White') will be deleted
self.assertEqual(self.cache.get('Walter'), None)
class TestCache(unittest.TestCase):
def setUp(self):
self.cache1 = LRUCache(2)
node1 = Node(1, 1)
node2 = Node(2, 2)
self.cache1.head.next = node1
node1.prev = self.cache1.head
node1.next = node2
node2.prev = node1
node2.next = self.cache1.tail
self.cache1.tail.prev = node2
self.cache1.valdict[1] = node1
self.cache1.valdict[2] = node2
def tearDown(self):
#del self.cache1
pass
def test_get(self):
print('Test_get')
# Simple Get
self.assertEqual(self.cache1.get(1),1)
self.assertEqual(self.cache1.get(2),2)
self.assertEqual(self.cache1.head.next.val,2)
self.assertEqual(self.cache1.tail.prev.val,1)
# Get value not in cache
self.assertEqual(self.cache1.get(3),-1)
def test_put(self):
print('test_put')
#Add with an overwrite
self.cache1.put(1,1)
self.assertEqual(self.cache1.head.next.val,1)
#Add with a full cache
self.cache1.put(3,3)
self.assertEqual(self.cache1.head.next.val,3)
self.assertEqual(self.cache1.head.next.next.val,1)
def test_delete(self):
print('Test Delete')
#Delete of value in cache
self.cache1.delete(1)
self.assertEqual(self.cache1.head.next.val, 2)
#Delete of value not in cache
self.cache1.delete(3)
self.assertEqual(self.cache1.head.next.val, 2)
self.assertEqual(self.cache1.head.next.next.val, 0)
def test_reset(self):
print('Test Reset')
self.cache1.reset()
self.assertEqual(self.cache1.head.next.val, 0)
def test_delete(self):
""" Test if Delete function actually deletes the (key, value) pair from the cache. """
cache = LRUCache(2)
cache.put(1, 1)
cache.delete(2)
self.assertEqual(
cache.cache, OrderedDict([(1, 1)]),
f"The result must be {OrderedDict([(1, 1)])} instead of {cache.cache}"
)
cache.delete(1)
self.assertEqual(
cache.cache, OrderedDict(),
f"The result must be {OrderedDict()} instead of {cache.cache}")
def test_all(self):
""" Test all functions! """
cache = LRUCache(2)
cache.put(1, 1)
cache.put(2, 2)
cache.get(1)
cache.put(3, 3)
cache.get(2)
cache.get(3)
cache.delete(3)
cache.reset()
cache.put(4, 4)
self.assertEqual(
cache.cache, OrderedDict([(4, 4)]),
f"The result must be {OrderedDict([(4, 4)])} instead of {cache.cache}"
)
from LRUCache import LRUCache
if __name__ == '__main__':
cache = LRUCache(100)
cache.set('Jesse', 'Pinkman')
cache.set('Walter', 'White')
cache.set('Jesse', 'James')
cache.get('Jesse') # вернёт 'James'
cache.delete('Walter')
cache.get('Walter') # вернёт ''
class TestLRUCache(unittest.TestCase):
def setUp(self):
self.capacity = 10
self.lrucache = LRUCache(self.capacity)
def test_addkey(self):
# Add Element to cache
key = get_random_key()
value = get_random_string()
self.lrucache.put(key, value)
self.assertEqual(self.lrucache.store[key].value, value)
self.assertEqual(self.lrucache.current_size, 1)
def test_getkey(self):
# Add Element to cache
key = get_random_key()
value = get_random_string()
self.lrucache.put(key, value)
self.assertEqual(self.lrucache.get(key), value)
self.assertEqual(self.lrucache.current_size, 1)
def test_getnonexistantkey(self):
# Add Element to cache
key = get_random_key()
self.assertEqual(self.lrucache.get(key), -1)
self.assertEqual(self.lrucache.current_size, 0)
def test_deletekey(self):
key = get_random_key()
value = get_random_string()
self.lrucache.put(key, value)
self.assertEqual(self.lrucache.current_size, 1)
self.lrucache.delete(key)
self.assertEqual(self.lrucache.get(key), -1)
self.assertEqual(self.lrucache.head, None)
def test_deletenonexistantkey(self):
key = get_random_key()
self.lrucache.delete(key)
def test_resetcache(self):
kv_pairs = get_key_value_pairs(length=5)
# Insert keys
for key, value in kv_pairs:
self.lrucache.put(key, value)
self.assertEqual(self.lrucache.current_size, len(kv_pairs))
self.lrucache.reset()
self.assertEqual(self.lrucache.current_size, 0)
self.assertEqual(self.lrucache.head, None)
self.assertEqual(self.lrucache.tail, None)
self.assertEqual(self.lrucache.store, {})
# Add get cache list
def test_updatekey(self):
key = get_random_key()
value = get_random_string()
self.lrucache.put(key, value)
self.assertEqual(self.lrucache.get(key), value)
value = get_random_string()
self.lrucache.put(key, value)
self.assertEqual(self.lrucache.get(key), value)
self.assertEqual(self.lrucache.current_size, 1)
def test_lrukey_addition(self):
"""[Test which is the top key after inital write]
"""
kv_pairs = get_key_value_pairs(length=5)
# Insert keys
for key, value in kv_pairs:
self.lrucache.put(key, value)
self.assertEqual(self.lrucache.current_size, len(kv_pairs))
self.assertEqual(self.lrucache.head.key, kv_pairs[-1][0])
def test_lrukey_access(self):
"""[Test which is the top key after read key access]
"""
kv_pairs = get_key_value_pairs(length=5)
# Insert keys
for key, value in kv_pairs:
self.lrucache.put(key, value)
self.assertEqual(self.lrucache.current_size, len(kv_pairs))
rand_index = random.randint(*(0, len(kv_pairs) - 1))
self.lrucache.get(kv_pairs[rand_index][0])
self.assertEqual(self.lrucache.head.key, kv_pairs[rand_index][0])
def test_lrukey_update(self):
"""[Test whcih is the top key after write key update]
"""
kv_pairs = get_key_value_pairs(length=5)
# Insert keys
for key, value in kv_pairs:
self.lrucache.put(key, value)
self.assertEqual(self.lrucache.current_size, len(kv_pairs))
rand_index = random.randint(*(0, len(kv_pairs) - 1))
value = get_random_string()
self.lrucache.put(kv_pairs[rand_index][0], value)
self.assertEqual(self.lrucache.head.key, kv_pairs[rand_index][0])
self.assertEqual(self.lrucache.head.value, value)
