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')
Exemplo n.º 3
0
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
Exemplo n.º 5
0
 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)
Exemplo n.º 6
0
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"]
Exemplo n.º 7
0
    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")
Exemplo n.º 8
0
    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")
Exemplo n.º 9
0
 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)
Exemplo n.º 10
0
    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")
Exemplo n.º 11
0
 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')
Exemplo n.º 13
0
    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')
Exemplo n.º 15
0
 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)
Exemplo n.º 16
0
 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)
Exemplo n.º 17
0
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))
Exemplo n.º 18
0
 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)
Exemplo n.º 19
0
    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)
Exemplo n.º 20
0
    def test_whenInsertedValue_shouldGetValue(self):
        # with
        cache = LRUCache(1)

        #when
        cache.insert("key1", "value1")
        value = cache.get("key1")

        # then
        assert value == "value1"
Exemplo n.º 21
0
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
Exemplo n.º 22
0
    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")
Exemplo n.º 23
0
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"))
Exemplo n.º 24
0
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')
Exemplo n.º 25
0
    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)
Exemplo n.º 26
0
    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"
Exemplo n.º 27
0
 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)
Exemplo n.º 28
0
    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")
Exemplo n.º 29
0
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)
Exemplo n.º 30
0
    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"
Exemplo n.º 31
0
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))
Exemplo n.º 32
0
 def test_non_existing_key(self):
     lru_cache = LRUCache(3)
     self.assertIsNone(lru_cache.get(1), "Failed")
Exemplo n.º 33
0
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)
Exemplo n.º 34
0
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)
Exemplo n.º 35
0
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")
Exemplo n.º 36
0
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')