Beispiel #1
0
 def test_update(self):
     l = LRU(2)
     l['a'] = 1
     self.assertEqual(l['a'], 1)
     l.update(a=2)
     self.assertEqual(l['a'], 2)
     l['b'] = 2
     self.assertEqual(l['b'], 2)
     l.update(b=3)
     self.assertEqual(('b', 3), l.peek_first_item())
     self.assertEqual(l['a'], 2)
     self.assertEqual(l['b'], 3)
     l.update({'a':1, 'b':2})
     self.assertEqual(('b', 2), l.peek_first_item())
     self.assertEqual(l['a'], 1)
     self.assertEqual(l['b'], 2)
     l.update()
     self.assertEqual(('b', 2), l.peek_first_item())
     l.update(a=2)
     self.assertEqual(('a', 2), l.peek_first_item())
Beispiel #2
0
def test_dict_behavior_matches_LRU_implementation():
    lru = LRU(100)
    lru_sql_dict = LRUSQLDict(
        sqlite3.connect(":memory:"),
        key_encoder,
        key_decoder,
        value_encoder,
        value_decoder,
        100,
    )
    kv_pairs = ((to_bytes(number), number) for number in range(20))
    for pair in kv_pairs:
        lru[pair[0]] = pair[1]
        lru_sql_dict[pair[0]] = pair[1]

        assert lru.peek_first_item() == (lru_sql_dict.head.key,
                                         lru_sql_dict.head.value)
        assert lru.peek_last_item() == (lru_sql_dict.tail.key,
                                        lru_sql_dict.tail.value)

    lru[to_bytes(10)]
    lru_sql_dict[to_bytes(10)]

    assert lru.peek_first_item() == (lru_sql_dict.head.key,
                                     lru_sql_dict.head.value)
    assert lru.peek_last_item() == (lru_sql_dict.tail.key,
                                    lru_sql_dict.tail.value)

    lru[to_bytes(15)] = 100
    lru_sql_dict[to_bytes(15)] = 100

    assert lru.peek_first_item() == (lru_sql_dict.head.key,
                                     lru_sql_dict.head.value)
    assert lru.peek_last_item() == (lru_sql_dict.tail.key,
                                    lru_sql_dict.tail.value)

    del lru[to_bytes(0)]
    del lru_sql_dict[to_bytes(0)]

    assert lru.peek_first_item() == (lru_sql_dict.head.key,
                                     lru_sql_dict.head.value)
    assert lru.peek_last_item() == (lru_sql_dict.tail.key,
                                    lru_sql_dict.tail.value)

    lru[to_bytes(100)] = 100
    lru_sql_dict[to_bytes(100)] = 100

    assert lru.peek_first_item() == (lru_sql_dict.head.key,
                                     lru_sql_dict.head.value)
    assert lru.peek_last_item() == (lru_sql_dict.tail.key,
                                    lru_sql_dict.tail.value)

    lru[to_bytes(5)]
    lru_sql_dict[to_bytes(5)]

    assert lru.peek_first_item() == (lru_sql_dict.head.key,
                                     lru_sql_dict.head.value)
    assert lru.peek_last_item() == (lru_sql_dict.tail.key,
                                    lru_sql_dict.tail.value)
Beispiel #3
0
 def test_peek_first_item(self):
     l = LRU(2)
     self.assertEqual(None, l.peek_first_item())
     l[1] = '1'
     l[2] = '2'
     self.assertEqual((2, '2'), l.peek_first_item())
Beispiel #4
0
from lru import LRU
l = LRU(5)  # Create an LRU container that can hold 5 items

print(l.peek_first_item(), l.peek_last_item())  #return the MRU key and LRU key
# Would print None None

for i in range(5):
    l[i] = str(i)
print(l.items())  # Prints items in MRU order
# Would print [(4, '4'), (3, '3'), (2, '2'), (1, '1'), (0, '0')]

print(l.peek_first_item(), l.peek_last_item())  #return the MRU key and LRU key
# Would print (4, '4') (0, '0')

l[5] = '5'  # Inserting one more item should evict the old item
print(l.items())
# Would print [(5, '5'), (4, '4'), (3, '3'), (2, '2'), (1, '1')]

l[3]  # Accessing an item would make it MRU
print(l.items())
# Would print [(3, '3'), (5, '5'), (4, '4'), (2, '2'), (1, '1')]
# Now 3 is in front

l.keys()  # Can get keys alone in MRU order
# Would print [3, 5, 4, 2, 1]

del l[4]  # Delete an item
print(l.items())
# Would print [(3, '3'), (5, '5'), (2, '2'), (1, '1')]

print(l.get_size())