class LRUCacheScaleTests(unittest.TestCase): def setUp(self): self.capacity = 5000000 self.__num_over_capacity = 500002 self.lru_cache = LRUCache(self.capacity) for i in xrange(1, self.capacity + self.__num_over_capacity): self.lru_cache.set('user' + str(i), 'user_number_' + str(i)) def tearDown(self): self.lru_cache = None @raises(KeyError) def test_set_and_get(self): """ lru element should be user2 and user1 sould be removed. """ self.assertEqual(self.lru_cache.get_lru_el(), self.lru_cache._cache_dict['user' + str(self.__num_over_capacity)]) self.lru_cache.get('user' + str(self.__num_over_capacity - 1)) def test_update(self): """ test update """ self.lru_cache.set('user' + str(self.__num_over_capacity + self.capacity/2), 'ANON_USER') self.assertTrue(self.lru_cache.get('user' + str(self.__num_over_capacity + self.capacity/2)) == 'ANON_USER') self.lru_cache.set('user' + str(self.__num_over_capacity), 'USER' + str(self.__num_over_capacity)) self.assertEqual(self.lru_cache.get_lru_el(), self.lru_cache._cache_dict['user' + str(self.__num_over_capacity + 1)])
def test_lru_cache_max_size(): c = LRUCache(1) c.set('a', 3) c.set('b', 33) assert c.get('b') == 33 with pytest.raises(ValueError): c.get('a')
class CacheTests(unittest.TestCase): def setUp(self): self.cache = LRUCache(3) def test_cache_overwrite_appropriately(self): self.cache.set('item1', 'a') self.cache.set('item2', 'b') self.cache.set('item3', 'c') self.cache.set('item2', 'z') # self.assertEqual(self.cache.get('item1'), 'a') self.assertEqual(self.cache.get('item2'), 'z') def test_cache_insertion_and_retrieval(self): self.cache.set('item1', 'a') self.cache.set('item2', 'b') self.cache.set('item3', 'c') # self.assertEqual(self.cache.get('item1'), 'a') self.cache.set('item4', 'd') # self.assertEqual(self.cache.get('item1'), 'a') self.assertEqual(self.cache.get('item3'), 'c') self.assertEqual(self.cache.get('item4'), 'd') # self.assertIsNone(self.cache.get('item2')) def test_cache_nonexistent_retrieval(self): self.assertIsNone(self.cache.get('nonexistent'))
def test_lru_cache_2(): c = LRUCache(10) c.set('a', 3) c.set('b', 13) c.set('c', 23) c.set('a', 33) assert c.get('a') == 33 assert c.get('b') == 13 assert c.get('c') == 23
def test_get_expired(self): capacity = 2 cache = LRUCache(capacity) cache.put(1, 3) cache.put(2, 5) cache.get(1) cache.put(3, 6) value = cache.get(2) self.assertEqual(-1, value)
def test_get_data(): empty_cache = LRUCache() assert empty_cache.get("BUM") == "BUM_MY_TEST_DATA" assert empty_cache._size == 1 assert empty_cache._head == empty_cache._dict["BUM"] assert empty_cache.get("BUM2") == "BUM2_MY_TEST_DATA" assert empty_cache._size == 2 assert empty_cache._head == empty_cache._dict["BUM2"] assert empty_cache._tail == empty_cache._dict["BUM"]
def test_item_removal_with_get(self): lru_cache = LRUCache(3) lru_cache.put(1, "abc") lru_cache.put(2, "edf") lru_cache.put(3, "ghi") lru_cache.get(1) lru_cache.put(4, "jkl") self.assertIsNone(lru_cache.get(2), "Failed")
def test_put_should_add_new_and_evict_tail(self): lru_cache = LRUCache(3) lru_cache.put(1, "abc") lru_cache.put(2, "edf") lru_cache.put(3, "ghi") lru_cache.put(4, "jkl") self.assertIsNone(lru_cache.get(1), "Failed") self.assertEqual(lru_cache.get(4), "jkl", "Failed")
def test_expired_after_update(self): capacity = 2 cache = LRUCache(capacity) cache.put(2, 1) cache.put(1, 1) cache.put(2, 3) cache.put(4, 1) value = cache.get(1) self.assertEqual(-1, value) value = cache.get(2) self.assertEqual(3, value)
def test_get_should_make_it_top(self): lru_cache = LRUCache(3) lru_cache.put(1, "abc") lru_cache.put(2, "edf") lru_cache.put(3, "ghi") self.assertEqual(lru_cache._get_head_key(), 3, "Failed") lru_cache.get(1) self.assertEqual(lru_cache._get_head_key(), 1, "Failed")
def test_lru_cache_generic(self): lru = LRUCache(2) self.assertEqual(lru.put(1, 1), None) self.assertEqual(lru.put(2, 2), None) self.assertEqual(lru.get(1), 1) self.assertEqual(lru.put(3, 3), None) self.assertEqual(lru.get(2), -1) self.assertEqual(lru.put(4, 4), None) self.assertEqual(lru.get(1), -1) self.assertEqual(lru.get(3), 3) self.assertEqual(lru.get(4), 4)
def test_lru_cache_max_size_with_get(): c = LRUCache(3) c.set('a', 3) c.set('b', 5) c.set('c', 7) assert c.get('a') == 3 c.set('d', 9) assert c.get('a') == 3 assert c.get('c') == 7 assert c.get('d') == 9 with pytest.raises(ValueError): c.get('b')
def test(self): cache = LRUCache(2) cache.put(1, 1) cache.put(2, 2) cache.get(1) cache.get(1) cache.get(2) cache.put(3, 3) actual = cache.get(2) self.assertEqual(-1, actual)
def test_lru_cache_max_size_2(): c = LRUCache(2) c.set('a', 3) c.set('b', 5) c.set('c', 7) c.set('d', 9) c.set('e', 11) c.set('f', 13) assert c.get('e') == 11 assert c.get('f') == 13 with pytest.raises(ValueError): c.get('d')
def test_put_update(self): capacity = 1 cache = LRUCache(capacity) cache.put(1, 3) cache.put(1, 5) value = cache.get(1) self.assertEqual(5, value)
def test_lru(self): lru = LRUCache(2) lru.add("k1", "v1") self.assertEqual(lru.debug_peek('k1'), 'v1') self.assertEqual(lru.debug_peek('k2'), None) lru.add("k2", "v2") self.assertEqual(lru.debug_peek('k2'), 'v2') lru.add("k3", "v3") self.assertEqual(lru.debug_peek('k1'), None) self.assertEqual(lru.debug_peek('k2'), 'v2') self.assertEqual(lru.get("k2"), "v2") lru.add("k4", "v4") self.assertEqual(lru.debug_peek('k3'), 'v3') lru.add("k5", "v5") self.assertEqual(lru.debug_peek('k3'), None) self.assertEqual(lru.get('k10086'), None)
def test_cache(cache_size, max_items, zipf_param, item_count, method): all_items = [i for i in range(int(max_items / 10))] Z = Accu_Zipfian(max_items, zipf_param) if method == "LRU": cache = LRUCache(cache_size) elif method == "Hyper": cache = HyperbolicCache(cache_size, 64) elif method == "LFU": cache = LFUCache(cache_size) cnt_hits = 0 cnt_miss = 0 for i in range(0, item_count): if i % 100 == 0: next_key = random.choice(all_items) else: next_key = 1 + Z.get_next(np.random.random())[0] #if next_key in all_items: # all_items.remove(next_key) ret_val = cache.get(next_key) if ret_val == 1: #found in cache cnt_hits += 1 else: #cache-miss cnt_miss += 1 cache.put(next_key, 0, 0) print(method, "Miss rate:", 100.0 * cnt_miss / (cnt_hits + cnt_miss))
def test_put_hit_capacity_update(self): capacity = 2 cache = LRUCache(capacity) cache.put(1, 3) cache.put(2, 5) cache.put(1, 2) value = cache.get(1) self.assertEqual(2, value)
def test_lru_cache(self): cache = LRUCache(2) cache.put(1, 1) cache.put(2, 2) actual = cache.get(1) self.assertEqual(1, actual) cache.put(3, 3) actual = cache.get(2) self.assertEqual(-1, actual) cache.put(4, 4) actual = cache.get(1) self.assertEqual(-1, actual) actual = cache.get(3) self.assertEqual(3, actual) actual = cache.get(4) self.assertEqual(4, actual)
def test_whenInsertedValue_shouldGetValue(self): # with cache = LRUCache(1) #when cache.insert("key1", "value1") value = cache.get("key1") # then assert value == "value1"
def test_lru_cache(): my_cache = LRUCache(2) my_cache.put(1, 1) my_cache.put(2, 2) assert len(my_cache) == 2 assert 1 == my_cache.get(1) # returns 1 my_cache.put(3, 3) # evicts key 2 assert 2 not in my_cache.cache_data assert -1 == my_cache.get(2) # returns -1 (not found) my_cache.put(4, 4) # evicts key 1 assert 1 not in my_cache.cache_data assert my_cache.get(1) == -1 # returns -1 (not found) assert my_cache.get(3) == 3 # returns 3 assert my_cache.get(4) == 4 # returns 4
def test_put_should_place_item_at_top_and_update_existing_key_value(self): lru_cache = LRUCache(3) lru_cache.put(1, "abc") lru_cache.put(2, "edf") lru_cache.put(3, "ghi") self.assertEqual(lru_cache._get_head_key(), 3, "Failed") lru_cache.put(2, "jkl") self.assertEqual(lru_cache._get_head_key(), 2, "Failed") self.assertEqual(lru_cache.get(2), "jkl", "Failed")
class CacheTests(unittest.TestCase): def setUp(self): self.cache = LRUCache(3) def test_cache_overwrite_appropriately(self): self.cache.set("item1", "a") self.cache.set("item2", "b") self.cache.set("item3", "c") self.cache.set("item2", "z") self.assertEqual(self.cache.get("item1"), "a") self.assertEqual(self.cache.get("item2"), "z") def test_cache_insertion_and_retrieval(self): self.cache.set("item1", "a") self.cache.set("item2", "b") self.cache.set("item3", "c") self.assertEqual(self.cache.get("item1"), "a") self.cache.set("item4", "d") self.assertEqual(self.cache.get("item1"), "a") self.assertEqual(self.cache.get("item3"), "c") self.assertEqual(self.cache.get("item4"), "d") self.assertIsNone(self.cache.get("item2")) def test_cache_nonexistent_retrieval(self): self.assertIsNone(self.cache.get("nonexistent"))
class CacheTests(unittest.TestCase): def setUp(self): self.cache = LRUCache(3) def test_cache_overwrite_appropriately(self): self.cache.set('item1', 'a') self.cache.set('item2', 'b') self.cache.set('item3', 'c') self.cache.set('item2', 'z') self.assertEqual(self.cache.get('item1'), 'a') self.assertEqual(self.cache.get('item2'), 'z')
def test_cache(self): test_actions = ["LRUCache", "put", "put", "put", "put", "put", "get", "put", "get", "get", "put", "get", "put", "put", "put", "get", "put", "get", "get", "get", "get", "put", "put", "get", "get", "get", "put", "put", "get", "put", "get", "put", "get", "get", "get", "put", "put", "put", "get", "put", "get", "get", "put", "put", "get", "put", "put", "put", "put", "get", "put", "put", "get", "put", "put", "get", "put", "put", "put", "put", "put", "get", "put", "put", "get", "put", "get", "get", "get", "put", "get", "get", "put", "put", "put", "put", "get", "put", "put", "put", "put", "get", "get", "get", "put", "put", "put", "get", "put", "put", "put", "get", "put", "put", "put", "get", "get", "get", "put", "put", "put", "put", "get", "put", "put", "put", "put", "put", "put", "put"] test_input = [[10], [10, 13], [3, 17], [6, 11], [10, 5], [9, 10], [13], [2, 19], [2], [3], [5, 25], [8], [9, 22], [5, 5], [1, 30], [11], [9, 12], [7], [5], [8], [9], [4, 30], [9, 3], [9], [10], [10], [6, 14], [3, 1], [3], [10, 11], [8], [2, 14], [1], [5], [4], [11, 4], [12, 24], [5, 18], [13], [7, 23], [8], [12], [3, 27], [2, 12], [5], [2, 9], [13, 4], [8, 18], [1, 7], [6], [9, 29], [8, 21], [5], [6, 30], [1, 12], [10], [4, 15], [7, 22], [11, 26], [8, 17], [9, 29], [5], [3, 4], [11, 30], [12], [4, 29], [3], [9], [6], [3, 4], [1], [10], [3, 29], [10, 28], [1, 20], [11, 13], [3], [3, 12], [3, 8], [10, 9], [3, 26], [8], [7], [5], [13, 17], [2, 27], [11, 15], [12], [9, 19], [2, 15], [3, 16], [1], [12, 17], [9, 1], [6, 19], [4], [5], [5], [8, 1], [11, 7], [5, 2], [9, 28], [1], [2, 2], [7, 4], [4, 22], [7, 24], [9, 26], [13, 28], [11, 26]] lru = None result = [] for i in range(len(test_actions)): if test_actions[i] is "LRUCache": lru = LRUCache(test_input[i][0]) result.append(None) elif test_actions[i] is "get": result.append(lru.get(test_input[i][0])) elif test_actions[i] is "put": lru.put(test_input[i][0], test_input[i][1]) result.append(None) self.assertListEqual([None, None, None, 1, None, -1, None, -1, 3, 4], result)
def test_whenInsertedValueOverLimit_shouldOnlyReturnLastInsertedValue( self): # with cache = LRUCache(1) # when cache.insert("key1", "value1") cache.insert("key2", "value2") value1 = cache.get("key1") value2 = cache.get("key2") # then assert not value1 assert value2 == "value2"
def test(self): cache = LRUCache(3) cache.put(1, 1) #1 cache.put(2, 2) #2,1 self.assertEqual(cache.get(1), 1) #1,2 cache.get(1) #// returns 1 cache.put(3, 3) #// evicts key 2 #3,1,2 self.assertEqual(cache.get(2), 2) #// returns -1 (not found) #2,3,1 cache.put(4, 4) #// evicts key 1 #4,2,3,1 self.assertEqual(cache.get(1), -1) #// returns -1 (not found) self.assertEqual(cache.get(3), 3) #// returns 3 cache.get(4) #// returns 4 self.assertEqual(cache.head.value, 4) cache.put(4, 2) self.assertEqual(cache.size, 3) self.assertEqual(cache.head.value, 2) self.assertEqual(cache.get(4), 2)
def test_del_should_remove_key_value(self): lru_cache = LRUCache(3) lru_cache.put(1, "abc") lru_cache.put(2, "edf") lru_cache.put(3, "ghi") #deleting head lru_cache.delete(3) self.assertEqual(lru_cache._get_head_key(), 2, "Failed") self.assertEqual(lru_cache._get_head_value(), "edf", "Failed") self.assertIsNone(lru_cache.get(3), "Failed") #deleting tail lru_cache.put(3, "ghi") lru_cache.delete(1) self.assertEqual(lru_cache._get_tail_key(), 2, "Failed")
class CacheTests(unittest.TestCase): def setUp(self): self.cache = LRUCache(3) def test_cache_overwrite_appropriately(self): self.cache.set('item1', 'a') self.cache.set('item2', 'b') self.cache.set('item3', 'c') self.cache.set('item2', 'z') self.assertEqual(self.cache.get('item1'), 'a') self.assertEqual(self.cache.get('item2'), 'z') def test_cache_insertion_and_retrieval(self): self.cache.set('item1', 'a') self.cache.set('item2', 'b') self.cache.set('item3', 'c') self.assertEqual(self.cache.get('item1'), 'a') self.cache.set('item4', 'd') self.assertEqual(self.cache.get('item1'), 'a') self.assertEqual(self.cache.get('item3'), 'c') self.assertEqual(self.cache.get('item4'), 'd') self.assertIsNone(self.cache.get('item2')) def test_cache_nonexistent_retrieval(self): self.assertIsNone(self.cache.get('nonexistent')) def test_cache_max_size(self): self.assertEqual(self.cache.limit, 3) self.assertEqual(len(self.cache), 0) self.cache.set('a', "a") self.assertEqual(len(self.cache), 1) self.cache.set('b', "z") self.assertEqual(len(self.cache), 2) self.cache.set('b', "b") self.assertEqual(len(self.cache), 2) self.cache.set('b', "b") self.assertEqual(len(self.cache), 2) self.assertEqual(self.cache.limit, 3) self.cache.set('c', "c") self.assertEqual(len(self.cache), 3) self.cache.set('d', "d") self.assertEqual(len(self.cache), 3) self.cache.set('e', "e") self.assertEqual(len(self.cache), 3)
def test_whenInsertedValues_shouldUpdateRecentlyUsedOnGet(self): # with cache = LRUCache(2) # when cache.insert("key1", "value1") cache.insert("key2", "value2") cache.get("key1") cache.insert("key3", "value3") value1 = cache.get("key1") value2 = cache.get("key2") value3 = cache.get("key3") # then assert cache.get("key1") == "value1" assert not cache.get("key2") assert cache.get("key3") == "value3"
def test_dynworkload(workload, cache_size, max_items, zipf_param, item_count, method): if method == "LRU": cache = LRUCache(cache_size) elif method == "Hyper": cache = HyperbolicCache(cache_size, 64) elif method == "HyperLFU": cache = HyperLFUCache(cache_size, 100) elif method == "LFU": cache = LFUCache(cache_size) cnt_hits = 0 cnt_miss = 0 for i in range(0, item_count): next_key = workload[i] ret_val = cache.get(next_key) if ret_val == 1: cnt_hits += 1 else: cnt_miss += 1 cache.put(next_key, 0, 0) print(method, "Miss rate:", 100.0 * cnt_miss / (cnt_hits + cnt_miss))
def test_non_existing_key(self): lru_cache = LRUCache(3) self.assertIsNone(lru_cache.get(1), "Failed")
class TestLRUCache(unittest.TestCase): def setUp(self): self.cache_size_max = 15000 self.num_urls = 15 self.base_url = "https://placeholdit.imgix.net/~text?txt=image" self.cache_dir = '/tmp/cache' self.lru = LRUCache(self.cache_size_max, self.cache_dir) def test_lru_cache(self): url_count = 0 out = [] while url_count < self.num_urls: url = "{}{}".format(self.base_url, url_count) out.append(self.lru.get(url)) url_count += 1 expected = [ '~text?txt=image11', '~text?txt=image12', '~text?txt=image13', '~text?txt=image14', ] self.assertEquals(os.listdir(self.cache_dir), expected) expected_log = [ 'https://placeholdit.imgix.net/~text?txt=image0 DOWNLOADED 3535', 'https://placeholdit.imgix.net/~text?txt=image1 DOWNLOADED 3440', 'https://placeholdit.imgix.net/~text?txt=image2 DOWNLOADED 3538', 'https://placeholdit.imgix.net/~text?txt=image3 DOWNLOADED 3537', 'https://placeholdit.imgix.net/~text?txt=image4 DOWNLOADED 3488', 'https://placeholdit.imgix.net/~text?txt=image5 DOWNLOADED 3511', 'https://placeholdit.imgix.net/~text?txt=image6 DOWNLOADED 3515', 'https://placeholdit.imgix.net/~text?txt=image7 DOWNLOADED 3499', 'https://placeholdit.imgix.net/~text?txt=image8 DOWNLOADED 3522', 'https://placeholdit.imgix.net/~text?txt=image9 DOWNLOADED 3511', 'https://placeholdit.imgix.net/~text?txt=image10 DOWNLOADED 3578', 'https://placeholdit.imgix.net/~text?txt=image11 DOWNLOADED 3459', 'https://placeholdit.imgix.net/~text?txt=image12 DOWNLOADED 3573', 'https://placeholdit.imgix.net/~text?txt=image13 DOWNLOADED 3580', 'https://placeholdit.imgix.net/~text?txt=image14 DOWNLOADED 3526', ] self.assertEquals(out, expected_log) def test_lru_cache_in_cache(self): url_count = 0 url_suffix = [1, 2, 3, 4, 5, 2, 1] out = [] while url_count < len(url_suffix): url = "{}{}".format(self.base_url, url_suffix[url_count]) out.append(self.lru.get(url)) url_count += 1 expected = [ '~text?txt=image1', '~text?txt=image2', '~text?txt=image4', '~text?txt=image5', ] self.assertEquals(os.listdir(self.cache_dir), expected) expected_log = [ 'https://placeholdit.imgix.net/~text?txt=image1 DOWNLOADED 3440', 'https://placeholdit.imgix.net/~text?txt=image2 DOWNLOADED 3538', 'https://placeholdit.imgix.net/~text?txt=image3 DOWNLOADED 3537', 'https://placeholdit.imgix.net/~text?txt=image4 DOWNLOADED 3488', 'https://placeholdit.imgix.net/~text?txt=image5 DOWNLOADED 3511', 'https://placeholdit.imgix.net/~text?txt=image2 IN_CACHE 3538', 'https://placeholdit.imgix.net/~text?txt=image1 DOWNLOADED 3440'] self.assertEquals(out, expected_log)
from lru_cache import LRUCache import random lru = LRUCache(5) for i in xrange(10): lru.set(i%8,random.randint(1,100)) for i in xrange(10): print lru.get(i%8)
from lru_cache import LRUCache my_cache = LRUCache(5) my_cache.set("key1", "bar") my_cache.set("key2", "bat") my_cache.print_cache print my_cache.get("key1") my_cache.set("key3", "bad") my_cache.set("key4", "ban") my_cache.set("key5", "bay") my_cache.print_cache() print my_cache.get("key4") my_cache.set("key6", "bla") my_cache.print_cache() print my_cache.get("key2")
class LRUCacheTests(unittest.TestCase): def setUp(self): self.lru_cache = LRUCache(3) self.lru_cache.set('user1', 'timur') self.lru_cache.set('user2', 'ogden') self.lru_cache.set('user3', 'francis') self.lru_cache.set('user4', 'amra') def tearDown(self): self.lru_cache = None @raises(KeyError) def test_key_error(self): """ First element should be removed from cache """ self.lru_cache.get('user1') def test_get(self): """ Checks to see if 3 most recent elements are in the cache """ self.assertTrue(self.lru_cache.get('user2') == 'ogden') self.assertTrue(self.lru_cache.get('user3') == 'francis') self.assertTrue(self.lru_cache.get('user4') == 'amra') @raises(KeyError) def test_lru_get_and_set(self): """ Performs a few get and set operations: user3 should be the least recently used element and should raise a key error. user2, user 4 and user5 should still be in the cache """ self.lru_cache.get('user2') self.lru_cache.set('user5', 'tom') self.assertTrue(self.lru_cache.get('user2') == 'ogden') self.assertTrue(self.lru_cache.get('user4') == 'amra') self.assertTrue(self.lru_cache.get('user5') == 'tom') self.lru_cache.get('user3') @raises(KeyError) def test_update(self): """ Updates user2 before adding new element. user4 should be the lru element and user3 should be removed from cache. """ self.lru_cache.set('user2', 'Ogden') self.lru_cache.set('user5', 'tom') self.assertTrue(self.lru_cache.get('user2') == 'Ogden') self.assertFalse(self.lru_cache.get('user2') == 'ogden') self.assertTrue(self.lru_cache.get_lru_el() == self.lru_cache._cache_dict['user4']) self.lru_cache.get('user3')