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)
class FibonacciWithLRU: def __init__(self): self.lru = LRUCache(4) def fib(self, number): self.lru.put(0, 0) self.lru.put(1, 1) for i in range(2, number + 1): self.lru.put(i, self.lru.get(i-1) + self.lru.get(i-2)) return self.lru.get(number)
def put(cache: LRUCache): ''' Inserts a new entry into the cache Args: cache: LRUCache instance ''' # check if cache exists, if not no-op if is_cache_none(cache): return # insert key, value into cache key, val = input('Enter key: ').strip(), input('Enter value: ') cache.put(key, val) print(f'successfully inserted [{key}: {val}] into the cache.')
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}")
class TestLRUCacheOverflow(unittest.TestCase): def setUp(self): self.capacity = 10 self.lrucache = LRUCache(self.capacity) def test_addmaxcapacity(self): kv_pairs = get_key_value_pairs(length=self.capacity) # Insert keys for key, value in kv_pairs: self.lrucache.put(key, value) self.assertEqual(self.lrucache.current_size, self.capacity) def test_addovermaxcapacity(self): kv_pairs = get_key_value_pairs(length=self.capacity * 2) # Insert keys for key, value in kv_pairs: self.lrucache.put(key, value) self.assertEqual(self.lrucache.current_size, self.capacity) self.assertEqual(self.lrucache.head.key, kv_pairs[-1][0]) def test_queuesnapshot(self): kv_pairs = get_key_value_pairs(length=self.capacity * 2) # Insert keys for key, value in kv_pairs: self.lrucache.put(key, value) # Keep track of key order manually keys = list(map(lambda item: item[0], kv_pairs[self.capacity:]))[::-1] # Add new element key = get_random_key() value = get_random_string() self.lrucache.put(key, value) keys.pop(-1) keys.insert(0, key) # Access last element self.lrucache.get(keys[-1]) keys.insert(0, keys.pop(-1)) # Update an element rand_index = random.randint(*(0, len(keys) - 1)) self.lrucache.put(keys[rand_index], get_random_string()) keys.insert(0, keys.pop(rand_index)) # Check Linked List self.assertListEqual(keys, get_list(self.lrucache.head))
def test_reset(self): """ Test if Reset function removes all items in the cache. """ cache = LRUCache(2) cache.put(1, 1) cache.reset() self.assertEqual( cache.cache, OrderedDict(), f"The result must be {OrderedDict()} instead of {cache.cache}") cache.put(1, 1) cache.put(2, 2) cache.reset() self.assertEqual( cache.cache, OrderedDict(), f"The result must be {OrderedDict()} instead of {cache.cache}")
def main(): test = LRUCache(3) test.put(1, "Hyderabad") test.put(2, "Delhi") test.put(3, "Mumbai") assert test.cache_dict == {1: "Hyderabad", 2: "Delhi", 3: "Mumbai"} print("Put test case passed") assert test.get(2) == "Delhi" print("Get test case passed") assert test.cache_dict == {1: "Hyderabad", 3: "Mumbai", 2: "Delhi"} print("After get dictionary is correct") test.put(4, "Bangalore") assert test.cache_dict == {3: "Mumbai", 2: "Delhi", 4: "Bangalore"} print("put after cache exceed passed") test.put(3, "Hyderabad") assert test.cache_dict == {3: "Hyderabad", 2: "Delhi", 4: "Bangalore"} print("LRU Success")
def main(): lru = LRUCache(4) lru.put(4) lru.put(2) assert lru.get_cache() == [4, 2], "put method failed" print("put method passed") assert lru.get(3) == -1, "put method failed" print("put method passed") lru.put(5) lru.put(4) assert lru.get(2) == 4, "put method failed" print("put method passed") assert lru.get_cache() == [2, 5, 4], "put method failed" print("get_cache passed") print(" LRU completed")
def test_get(self): """ Test if Get function returns the value of a key correctly. """ cache = LRUCache(2) self.assertEqual( cache.get(1), -1, "It must return -1 (i.e. key doesn't exist in the cache") cache.put(1, 1) self.assertEqual(cache.get(1), 1, "It must return 1 (i.e. key exists in the cache") cache.put(2, 2) cache.get(1) self.assertEqual( cache.cache, OrderedDict([(2, 2), (1, 1)]), f"The result must be {OrderedDict([(2, 2), (1, 1)])} instead of {cache.cache}" ) cache.get(2) self.assertEqual(cache.get(2), 2, "It must return 2 (i.e. key exists in the cache")
def supply_sample_cache(): # initialize sample cache with capacity = 5 cache = LRUCache(6) # insert sample data cache.put('one', 1) cache.put('two', 2) cache.put('three', 3) cache.put('four', 4) cache.put('five', 5) return 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}" )
def test_put(self): """ Test if Put function add or update the value of a key correctly. """ cache = LRUCache(2) cache.put(1, 1) self.assertEqual( cache.cache, OrderedDict([(1, 1)]), f"The result must be {OrderedDict([(1, 1)])} instead of {cache.cache}" ) cache.put(2, 2) self.assertEqual( cache.cache, OrderedDict([(1, 1), (2, 2)]), f"The result must be {OrderedDict([(1, 1), (2, 2)])} instead of {cache.cache}" ) cache.put(3, 3) self.assertEqual( cache.cache, OrderedDict([(2, 2), (3, 3)]), f"The result must be {OrderedDict([(2, 2), (3, 3)])} instead of {cache.cache}" )
class Libraries: def __init__(self, api_file_path='./api.txt'): self.api_file_path = api_file_path self.api_key = None self.payload = None self.load_api_key() self.package_cache = {} self.response_caches = LRUCache(150) return def load_api_key(self): if 'API_KEY' in os.environ: self.api_key = os.environ['API_KEY'] else: with open(self.api_file_path, 'r') as file: self.api_key = file.read() return def init_api_key(self, paramenters=None): self.payload = dict() self.payload.update({'api_key': self.api_key}) return def get_response(self, url): resp = self.response_caches.get(url) if resp is None: resp = get_response(url, self.payload) self.response_caches.put(url, resp) return resp def get_processed_package(self, package_name='requests'): if package_name not in self.package_cache: package = self.get_package(package_name) package['dependencies'] = self.get_dependencies(package)['dependencies'] package['dependency_graph'] = self.preorder_label_parent(package, True) package['dependency_count'] = len(package['dependency_graph'][0]) - 1 repo = self.get_repository(package) if repo is not None: del repo['name'] package.update(repo) self.package_cache[package_name] = package return self.package_cache[package_name] def get_package(self, package_name='requests'): url = 'https://libraries.io/api/search?q={}'.format(package_name) response = self.get_response(url) results = response.json() filtered_results = list(filter(lambda obj: obj['name'].lower() == package_name.lower() and obj['stars'] > 0, results)) json = filtered_results[0] if len(filtered_results) > 0 else results[0] del json['versions'] del json['normalized_licenses'] del json['keywords'] del json['latest_stable_release'] return json def get_dependencies(self, obj): url = 'https://libraries.io/api/{}/{}/latest/tree'.format(obj['platform'], obj['name']) response = self.get_response(url) json = response.json() return json def get_repository(self, obj): repo_path = obj['repository_url'].replace('https://', '').replace('.com', '') json = None if 'github' in repo_path: url = 'https://libraries.io/api/{}'.format(repo_path) response = self.get_response(url) if response.status_code == 200: json = response.json() return json def preorder_label_parent(self, parent, is_tree=False, node_list=None, links=None): if node_list is None: node_list=list() if links is None: links=[] if 'id' not in parent: parent['id'] = parent['name'] if not is_tree else str(uuid.uuid4()) if next((x for x in node_list if x['id'] == parent['id']), None) is None: node_list.append(parent) if 'dependencies' in parent: for child in parent.get('dependencies'): child['name'] = child['dependency']['project_name'] child['id'] = child['name'] if not is_tree else str(uuid.uuid4()) links.append((parent['id'], child['id'])) self.preorder_label_parent(child, is_tree, node_list, links) return node_list, links
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)
class TestLRUCache(unittest.TestCase): def setUp(self): self.test_cache = LRUCache(3) self.test_cache.put("1", "one") self.test_cache.put("2", "two") self.test_cache.put("3", "three") def test_cache_capacity_1(self): self.test_cache.put("4", "four") self.test_cache.put("5", "five") self.test_cache.put("6", "six") val = self.test_cache.get("4") self.assertEqual(val, 'four') def test_cache_capacity_2(self): self.test_cache.put("4", "four") self.test_cache.put("5", "five") self.test_cache.put("6", "six") val = self.test_cache.get("3") self.assertEqual(val, None) def test_cache_touch(self): val = self.test_cache.get("1") self.test_cache.put("4", "four") self.test_cache.put("5", "five") val = self.test_cache.get("1") self.assertEqual(val, "one") def test_cache_purge(self): self.test_cache.purge("1") val = self.test_cache.get("1") self.assertEqual(val, None) def test_cache_clear(self): self.test_cache.clear() val = self.test_cache.get("1") self.assertEqual(val, None) def test_cache_statistics(self): self.test_cache.get("1") self.test_cache.get("2") self.test_cache.get("3") self.test_cache.get("4") self.test_cache.get("5") self.test_cache.get("6") res = {"hit": 3, "miss": 3, "percentage": 0.5} self.assertEqual(self.test_cache.stats(), res) def test_iterable(self): all_data = {(x, y) for x, y in self.test_cache} actual_data = {("1", "one"), ("2", "two"), ("3", "three")} self.assertEqual(all_data, actual_data) def test_contains(self): self.assertTrue("3" in self.test_cache) def test_not_contains(self): self.assertFalse("4" in self.test_cache) def test_len_n(self): self.assertEqual(len(self.test_cache), 3)
def create_and_fill_mock_cache(max_size: int, max_age: int): cache = LRUCache(max_size, max_age) for i in range(max_size): cache.put(i, 'value{}'.format(i)) return cache
def supply_one_item_cache(): #initialize sample one item cache with capacity = 1 cache = LRUCache(1) cache.put('one', 1) return cache
from LRUCache import LRUCache if __name__ == '__main__': cache = LRUCache(2) cache.put(1, 1) cache.printQueue() cache.put(2, 2) cache.printQueue() print(cache.get(1)) # 1 cache.printQueue() cache.put(3, 3) cache.printQueue() print(cache.get(2)) print(cache.Q.dict)
from LRUCache import LRUCache #["LRUCache","get","put","get","put","put","get","get"] #[[2],[2],[2,6],[1],[1,5],[1,2],[1],[2]] if __name__ == '__main__': l1 = ["LRUCache", "get", "put", "get", "put", "put", "get", "get"] l2 = [[2], [2], [2, 6], [1], [1, 5], [1, 2], [1], [2]] for cmd, arg in zip(l1, l2): if cmd == "LRUCache": cache = LRUCache(arg[0]) if cmd == "get": print("get", arg[0]) r = cache.get(arg[0]) print(r) if cmd == "put": print("put", arg) cache.put(arg[0], arg[1]) cache.printQueue()
class LRUCacheTest(unittest.TestCase): def test_default_behaviour(self): self.LRU = LRUCache(2) self.assertEqual(self.LRU.get(1), -1) self.LRU.put(1, 1) self.assertEqual(self.LRU.get(1), 1) self.LRU.put(2, 4) self.LRU.put(3, 9) self.LRU.put(4, 16) self.assertEqual(self.LRU.get(4), 16) self.assertEqual(self.LRU.get(2), -1) self.assertEqual(len(self.LRU.get_all()), 2) self.LRU.put(5, 5) self.LRU.put(6, 6) self.LRU.put(7, 7) self.assertEqual(self.LRU.get(6), 6) self.assertEqual(self.LRU.get(5), -1) def test_lru_cache_expired(self): self.LRU = LRUCache(3) self.LRU.put(1, 1, 2) self.assertEqual(self.LRU.get(1), 1) time.sleep(3) self.assertEqual(self.LRU.get(1), -1) self.LRU.put(1, 1, 3) self.LRU.put(2, 2, 10) self.LRU.put(3, 3, 3) time.sleep(4) self.assertEqual(self.LRU.get(2), 2) self.assertEqual(self.LRU.get(3), -1) self.assertEqual(self.LRU.get(1), -1)