/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to brzlib/tests/test_lru_cache.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/tests/test_lru_cache.py
16
16
 
17
17
"""Tests for the lru_cache module."""
18
18
 
19
 
from .. import (
 
19
from brzlib import (
20
20
    lru_cache,
 
21
    symbol_versioning,
21
22
    tests,
22
23
    )
23
24
 
53
54
        yield node
54
55
        node = node_next
55
56
 
56
 
 
 
57
 
57
58
class TestLRUCache(tests.TestCase):
58
59
    """Test that LRU cache properly keeps track of entries."""
59
60
 
98
99
    def test_add__null_key(self):
99
100
        cache = lru_cache.LRUCache(max_cache=10)
100
101
        self.assertRaises(ValueError,
101
 
                          cache.__setitem__, lru_cache._null_key, 1)
 
102
            cache.__setitem__, lru_cache._null_key, 1)
102
103
 
103
104
    def test_overflow(self):
104
105
        """Adding extra entries will pop out old ones."""
127
128
 
128
129
        self.assertFalse('foo' in cache)
129
130
 
 
131
    def test_cleanup_function_deprecated(self):
 
132
        """Test that per-node cleanup functions are no longer allowed"""
 
133
        cache = lru_cache.LRUCache()
 
134
        self.assertRaises(ValueError, self.applyDeprecated,
 
135
            symbol_versioning.deprecated_in((2, 5, 0)),
 
136
            cache.add, "key", 1, cleanup=lambda: None)
 
137
 
130
138
    def test_len(self):
131
139
        cache = lru_cache.LRUCache(max_cache=10, after_cleanup_count=10)
132
140
 
144
152
 
145
153
        self.assertEqual(8, len(cache))
146
154
 
147
 
        cache[1] = 15  # replacement
 
155
        cache[1] = 15 # replacement
148
156
 
149
157
        self.assertEqual(8, len(cache))
150
158
 
276
284
        cache[9] = 10
277
285
        cache[10] = 11
278
286
        self.assertEqual([3, 4, 5, 6, 7, 8, 9, 10], sorted(cache.keys()))
279
 
        cache[11] = 12  # triggers cleanup back to new after_cleanup_count
 
287
        cache[11] = 12 # triggers cleanup back to new after_cleanup_count
280
288
        self.assertEqual([6, 7, 8, 9, 10, 11], sorted(cache.keys()))
281
289
 
282
290
 
285
293
    def test_basic_init(self):
286
294
        cache = lru_cache.LRUSizeCache()
287
295
        self.assertEqual(2048, cache._max_cache)
288
 
        self.assertEqual(int(cache._max_size * 0.8), cache._after_cleanup_size)
 
296
        self.assertEqual(int(cache._max_size*0.8), cache._after_cleanup_size)
289
297
        self.assertEqual(0, cache._value_size)
290
298
 
291
299
    def test_add__null_key(self):
292
300
        cache = lru_cache.LRUSizeCache()
293
301
        self.assertRaises(ValueError,
294
 
                          cache.__setitem__, lru_cache._null_key, 1)
 
302
            cache.__setitem__, lru_cache._null_key, 1)
295
303
 
296
304
    def test_add_tracks_size(self):
297
305
        cache = lru_cache.LRUSizeCache()
318
326
        self.assertEqual({'test': 'key'}, cache.as_dict())
319
327
        cache['test2'] = 'key that is too big'
320
328
        self.assertEqual(3, cache._value_size)
321
 
        self.assertEqual({'test': 'key'}, cache.as_dict())
 
329
        self.assertEqual({'test':'key'}, cache.as_dict())
322
330
        # If we would add a key, only to cleanup and remove all cached entries,
323
331
        # then obviously that value should not be stored
324
332
        cache['test3'] = 'bigkey'
325
333
        self.assertEqual(3, cache._value_size)
326
 
        self.assertEqual({'test': 'key'}, cache.as_dict())
 
334
        self.assertEqual({'test':'key'}, cache.as_dict())
327
335
 
328
336
        cache['test4'] = 'bikey'
329
337
        self.assertEqual(3, cache._value_size)
330
 
        self.assertEqual({'test': 'key'}, cache.as_dict())
 
338
        self.assertEqual({'test':'key'}, cache.as_dict())
331
339
 
332
340
    def test_adding_clears_cache_based_on_size(self):
333
341
        """The cache is cleared in LRU order until small enough"""
334
342
        cache = lru_cache.LRUSizeCache(max_size=20)
335
 
        cache['key1'] = 'value'  # 5 chars
336
 
        cache['key2'] = 'value2'  # 6 chars
337
 
        cache['key3'] = 'value23'  # 7 chars
338
 
        self.assertEqual(5 + 6 + 7, cache._value_size)
339
 
        cache['key2']  # reference key2 so it gets a newer reference time
340
 
        cache['key4'] = 'value234'  # 8 chars, over limit
 
343
        cache['key1'] = 'value' # 5 chars
 
344
        cache['key2'] = 'value2' # 6 chars
 
345
        cache['key3'] = 'value23' # 7 chars
 
346
        self.assertEqual(5+6+7, cache._value_size)
 
347
        cache['key2'] # reference key2 so it gets a newer reference time
 
348
        cache['key4'] = 'value234' # 8 chars, over limit
341
349
        # We have to remove 2 keys to get back under limit
342
 
        self.assertEqual(6 + 8, cache._value_size)
343
 
        self.assertEqual({'key2': 'value2', 'key4': 'value234'},
 
350
        self.assertEqual(6+8, cache._value_size)
 
351
        self.assertEqual({'key2':'value2', 'key4':'value234'},
344
352
                         cache.as_dict())
345
353
 
346
354
    def test_adding_clears_to_after_cleanup_size(self):
347
355
        cache = lru_cache.LRUSizeCache(max_size=20, after_cleanup_size=10)
348
 
        cache['key1'] = 'value'  # 5 chars
349
 
        cache['key2'] = 'value2'  # 6 chars
350
 
        cache['key3'] = 'value23'  # 7 chars
351
 
        self.assertEqual(5 + 6 + 7, cache._value_size)
352
 
        cache['key2']  # reference key2 so it gets a newer reference time
353
 
        cache['key4'] = 'value234'  # 8 chars, over limit
 
356
        cache['key1'] = 'value' # 5 chars
 
357
        cache['key2'] = 'value2' # 6 chars
 
358
        cache['key3'] = 'value23' # 7 chars
 
359
        self.assertEqual(5+6+7, cache._value_size)
 
360
        cache['key2'] # reference key2 so it gets a newer reference time
 
361
        cache['key4'] = 'value234' # 8 chars, over limit
354
362
        # We have to remove 3 keys to get back under limit
355
363
        self.assertEqual(8, cache._value_size)
356
 
        self.assertEqual({'key4': 'value234'}, cache.as_dict())
 
364
        self.assertEqual({'key4':'value234'}, cache.as_dict())
357
365
 
358
366
    def test_custom_sizes(self):
359
367
        def size_of_list(lst):
361
369
        cache = lru_cache.LRUSizeCache(max_size=20, after_cleanup_size=10,
362
370
                                       compute_size=size_of_list)
363
371
 
364
 
        cache['key1'] = ['val', 'ue']  # 5 chars
365
 
        cache['key2'] = ['val', 'ue2']  # 6 chars
366
 
        cache['key3'] = ['val', 'ue23']  # 7 chars
367
 
        self.assertEqual(5 + 6 + 7, cache._value_size)
368
 
        cache['key2']  # reference key2 so it gets a newer reference time
369
 
        cache['key4'] = ['value', '234']  # 8 chars, over limit
 
372
        cache['key1'] = ['val', 'ue'] # 5 chars
 
373
        cache['key2'] = ['val', 'ue2'] # 6 chars
 
374
        cache['key3'] = ['val', 'ue23'] # 7 chars
 
375
        self.assertEqual(5+6+7, cache._value_size)
 
376
        cache['key2'] # reference key2 so it gets a newer reference time
 
377
        cache['key4'] = ['value', '234'] # 8 chars, over limit
370
378
        # We have to remove 3 keys to get back under limit
371
379
        self.assertEqual(8, cache._value_size)
372
 
        self.assertEqual({'key4': ['value', '234']}, cache.as_dict())
 
380
        self.assertEqual({'key4':['value', '234']}, cache.as_dict())
373
381
 
374
382
    def test_cleanup(self):
375
383
        cache = lru_cache.LRUSizeCache(max_size=20, after_cleanup_size=10)
376
384
 
377
385
        # Add these in order
378
 
        cache['key1'] = 'value'  # 5 chars
379
 
        cache['key2'] = 'value2'  # 6 chars
380
 
        cache['key3'] = 'value23'  # 7 chars
381
 
        self.assertEqual(5 + 6 + 7, cache._value_size)
 
386
        cache['key1'] = 'value' # 5 chars
 
387
        cache['key2'] = 'value2' # 6 chars
 
388
        cache['key3'] = 'value23' # 7 chars
 
389
        self.assertEqual(5+6+7, cache._value_size)
382
390
 
383
391
        cache.cleanup()
384
392
        # Only the most recent fits after cleaning up
424
432
        self.assertEqual([2, 3, 4, 5, 6], sorted(cache.keys()))
425
433
        cache[7] = 'stu'
426
434
        self.assertEqual([4, 5, 6, 7], sorted(cache.keys()))
 
435