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)
