/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 breezy/tests/test_lru_cache.py

  • Committer: Jelmer Vernooij
  • Date: 2018-05-06 11:48:54 UTC
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@jelmer.uk-20180506114854-h4qd9ojaqy8wxjsd
Move .mailmap to root.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_lru_cache.py
53
53
        yield node
54
54
        node = node_next
55
55
 
56
 
 
 
56
 
57
57
class TestLRUCache(tests.TestCase):
58
58
    """Test that LRU cache properly keeps track of entries."""
59
59
 
98
98
    def test_add__null_key(self):
99
99
        cache = lru_cache.LRUCache(max_cache=10)
100
100
        self.assertRaises(ValueError,
101
 
                          cache.__setitem__, lru_cache._null_key, 1)
 
101
            cache.__setitem__, lru_cache._null_key, 1)
102
102
 
103
103
    def test_overflow(self):
104
104
        """Adding extra entries will pop out old ones."""
144
144
 
145
145
        self.assertEqual(8, len(cache))
146
146
 
147
 
        cache[1] = 15  # replacement
 
147
        cache[1] = 15 # replacement
148
148
 
149
149
        self.assertEqual(8, len(cache))
150
150
 
276
276
        cache[9] = 10
277
277
        cache[10] = 11
278
278
        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
 
279
        cache[11] = 12 # triggers cleanup back to new after_cleanup_count
280
280
        self.assertEqual([6, 7, 8, 9, 10, 11], sorted(cache.keys()))
281
281
 
282
282
 
285
285
    def test_basic_init(self):
286
286
        cache = lru_cache.LRUSizeCache()
287
287
        self.assertEqual(2048, cache._max_cache)
288
 
        self.assertEqual(int(cache._max_size * 0.8), cache._after_cleanup_size)
 
288
        self.assertEqual(int(cache._max_size*0.8), cache._after_cleanup_size)
289
289
        self.assertEqual(0, cache._value_size)
290
290
 
291
291
    def test_add__null_key(self):
292
292
        cache = lru_cache.LRUSizeCache()
293
293
        self.assertRaises(ValueError,
294
 
                          cache.__setitem__, lru_cache._null_key, 1)
 
294
            cache.__setitem__, lru_cache._null_key, 1)
295
295
 
296
296
    def test_add_tracks_size(self):
297
297
        cache = lru_cache.LRUSizeCache()
318
318
        self.assertEqual({'test': 'key'}, cache.as_dict())
319
319
        cache['test2'] = 'key that is too big'
320
320
        self.assertEqual(3, cache._value_size)
321
 
        self.assertEqual({'test': 'key'}, cache.as_dict())
 
321
        self.assertEqual({'test':'key'}, cache.as_dict())
322
322
        # If we would add a key, only to cleanup and remove all cached entries,
323
323
        # then obviously that value should not be stored
324
324
        cache['test3'] = 'bigkey'
325
325
        self.assertEqual(3, cache._value_size)
326
 
        self.assertEqual({'test': 'key'}, cache.as_dict())
 
326
        self.assertEqual({'test':'key'}, cache.as_dict())
327
327
 
328
328
        cache['test4'] = 'bikey'
329
329
        self.assertEqual(3, cache._value_size)
330
 
        self.assertEqual({'test': 'key'}, cache.as_dict())
 
330
        self.assertEqual({'test':'key'}, cache.as_dict())
331
331
 
332
332
    def test_adding_clears_cache_based_on_size(self):
333
333
        """The cache is cleared in LRU order until small enough"""
334
334
        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
 
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
341
341
        # 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'},
 
342
        self.assertEqual(6+8, cache._value_size)
 
343
        self.assertEqual({'key2':'value2', 'key4':'value234'},
344
344
                         cache.as_dict())
345
345
 
346
346
    def test_adding_clears_to_after_cleanup_size(self):
347
347
        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
 
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
354
354
        # We have to remove 3 keys to get back under limit
355
355
        self.assertEqual(8, cache._value_size)
356
 
        self.assertEqual({'key4': 'value234'}, cache.as_dict())
 
356
        self.assertEqual({'key4':'value234'}, cache.as_dict())
357
357
 
358
358
    def test_custom_sizes(self):
359
359
        def size_of_list(lst):
361
361
        cache = lru_cache.LRUSizeCache(max_size=20, after_cleanup_size=10,
362
362
                                       compute_size=size_of_list)
363
363
 
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
 
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
370
370
        # We have to remove 3 keys to get back under limit
371
371
        self.assertEqual(8, cache._value_size)
372
 
        self.assertEqual({'key4': ['value', '234']}, cache.as_dict())
 
372
        self.assertEqual({'key4':['value', '234']}, cache.as_dict())
373
373
 
374
374
    def test_cleanup(self):
375
375
        cache = lru_cache.LRUSizeCache(max_size=20, after_cleanup_size=10)
376
376
 
377
377
        # 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)
 
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)
382
382
 
383
383
        cache.cleanup()
384
384
        # Only the most recent fits after cleaning up
424
424
        self.assertEqual([2, 3, 4, 5, 6], sorted(cache.keys()))
425
425
        cache[7] = 'stu'
426
426
        self.assertEqual([4, 5, 6, 7], sorted(cache.keys()))
 
427