/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_fifo_cache.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_fifo_cache.py
20
20
    fifo_cache,
21
21
    tests,
22
22
    )
 
23
from ..sixish import (
 
24
    viewitems,
 
25
    viewkeys,
 
26
    viewvalues,
 
27
    )
23
28
 
24
29
 
25
30
class TestFIFOCache(tests.TestCase):
34
39
        self.assertEqual(2, c.get(1))
35
40
        self.assertEqual(2, c.get(1, None))
36
41
        self.assertEqual([1], list(c))
37
 
        self.assertEqual({1}, c.keys())
38
 
        self.assertEqual([(1, 2)], sorted(c.items()))
39
 
        self.assertEqual([2], sorted(c.values()))
 
42
        self.assertEqual({1}, viewkeys(c))
 
43
        self.assertEqual([(1, 2)], sorted(viewitems(c)))
 
44
        self.assertEqual([2], sorted(viewvalues(c)))
40
45
        self.assertEqual({1: 2}, c)
41
46
 
42
47
    def test_cache_size(self):
53
58
        self.assertEqual(None, c.get(1))
54
59
        self.assertEqual(None, c.get(1, None))
55
60
        self.assertEqual([], list(c))
56
 
        self.assertEqual(set(), c.keys())
57
 
        self.assertEqual([], list(c.items()))
58
 
        self.assertEqual([], list(c.values()))
 
61
        self.assertEqual(set(), viewkeys(c))
 
62
        self.assertEqual([], list(viewitems(c)))
 
63
        self.assertEqual([], list(viewvalues(c)))
59
64
        self.assertEqual({}, c)
60
65
 
61
66
    def test_add_maintains_fifo(self):
64
69
        c[2] = 3
65
70
        c[3] = 4
66
71
        c[4] = 5
67
 
        self.assertEqual({1, 2, 3, 4}, c.keys())
 
72
        self.assertEqual({1, 2, 3, 4}, viewkeys(c))
68
73
        c[5] = 6
69
74
        # This should pop out the oldest entry
70
 
        self.assertEqual({2, 3, 4, 5}, c.keys())
 
75
        self.assertEqual({2, 3, 4, 5}, viewkeys(c))
71
76
        # Replacing an item doesn't change the stored keys
72
77
        c[2] = 7
73
 
        self.assertEqual({2, 3, 4, 5}, c.keys())
 
78
        self.assertEqual({2, 3, 4, 5}, viewkeys(c))
74
79
        # But it does change the position in the FIFO
75
80
        c[6] = 7
76
 
        self.assertEqual({2, 4, 5, 6}, c.keys())
 
81
        self.assertEqual({2, 4, 5, 6}, viewkeys(c))
77
82
        self.assertEqual([4, 5, 2, 6], list(c._queue))
78
83
 
79
84
    def test_default_after_cleanup_count(self):
85
90
        c[4] = 5
86
91
        c[5] = 6
87
92
        # So far, everything fits
88
 
        self.assertEqual({1, 2, 3, 4, 5}, c.keys())
 
93
        self.assertEqual({1, 2, 3, 4, 5}, viewkeys(c))
89
94
        c[6] = 7
90
95
        # But adding one more should shrink down to after_cleanup_count
91
 
        self.assertEqual({3, 4, 5, 6}, c.keys())
 
96
        self.assertEqual({3, 4, 5, 6}, viewkeys(c))
92
97
 
93
98
    def test_clear(self):
94
99
        c = fifo_cache.FIFOCache(5)
98
103
        c[4] = 5
99
104
        c[5] = 6
100
105
        c.cleanup()
101
 
        self.assertEqual({2, 3, 4, 5}, c.keys())
 
106
        self.assertEqual({2, 3, 4, 5}, viewkeys(c))
102
107
        c.clear()
103
 
        self.assertEqual(set(), c.keys())
 
108
        self.assertEqual(set(), viewkeys(c))
104
109
        self.assertEqual([], list(c._queue))
105
110
        self.assertEqual({}, c)
106
111
 
189
194
 
190
195
    def test_cleanup_funcs(self):
191
196
        log = []
192
 
 
193
197
        def logging_cleanup(key, value):
194
198
            log.append((key, value))
195
199
        c = fifo_cache.FIFOCache(5, 4)
196
200
        c.add(1, 2, cleanup=logging_cleanup)
197
201
        c.add(2, 3, cleanup=logging_cleanup)
198
202
        c.add(3, 4, cleanup=logging_cleanup)
199
 
        c.add(4, 5, cleanup=None)  # no cleanup for 4
200
 
        c[5] = 6  # no cleanup for 5
 
203
        c.add(4, 5, cleanup=None) # no cleanup for 4
 
204
        c[5] = 6 # no cleanup for 5
201
205
        self.assertEqual([], log)
202
206
        # Adding another key should cleanup 1 & 2
203
207
        c.add(6, 7, cleanup=logging_cleanup)
221
225
 
222
226
    def test_cleanup_at_deconstruct(self):
223
227
        log = []
224
 
 
225
228
        def logging_cleanup(key, value):
226
229
            log.append((key, value))
227
230
        c = fifo_cache.FIFOCache()
245
248
        self.assertEqual('2', c.get(1))
246
249
        self.assertEqual('2', c.get(1, None))
247
250
        self.assertEqual([1], list(c))
248
 
        self.assertEqual({1}, c.keys())
249
 
        self.assertEqual([(1, '2')], sorted(c.items()))
250
 
        self.assertEqual(['2'], sorted(c.values()))
 
251
        self.assertEqual({1}, viewkeys(c))
 
252
        self.assertEqual([(1, '2')], sorted(viewitems(c)))
 
253
        self.assertEqual(['2'], sorted(viewvalues(c)))
251
254
        self.assertEqual({1: '2'}, c)
252
 
        self.assertEqual(1024 * 1024, c.cache_size())
 
255
        self.assertEqual(1024*1024, c.cache_size())
253
256
 
254
257
    def test_missing(self):
255
258
        c = fifo_cache.FIFOSizeCache()
259
262
        self.assertEqual(None, c.get(1))
260
263
        self.assertEqual(None, c.get(1, None))
261
264
        self.assertEqual([], list(c))
262
 
        self.assertEqual(set(), c.keys())
263
 
        self.assertEqual([], list(c.items()))
264
 
        self.assertEqual([], list(c.values()))
 
265
        self.assertEqual(set(), viewkeys(c))
 
266
        self.assertEqual([], list(viewitems(c)))
 
267
        self.assertEqual([], list(viewvalues(c)))
265
268
        self.assertEqual({}, c)
266
269
 
267
270
    def test_add_maintains_fifo(self):
270
273
        c[2] = 'cde'
271
274
        c[3] = 'fghi'
272
275
        self.assertEqual({1: 'ab', 2: 'cde', 3: 'fghi'}, c)
273
 
        c[4] = 'jkl'  # Collapse
 
276
        c[4] = 'jkl' # Collapse
274
277
        self.assertEqual({3: 'fghi', 4: 'jkl'}, c)
275
278
        # Replacing an item will bump it to the end of the queue
276
279
        c[3] = 'mnop'
280
283
 
281
284
    def test_adding_large_key(self):
282
285
        c = fifo_cache.FIFOSizeCache(10, 8)
283
 
        c[1] = 'abcdefgh'  # Adding a large key won't get cached at all
 
286
        c[1] = 'abcdefgh' # Adding a large key won't get cached at all
284
287
        self.assertEqual({}, c)
285
288
        c[1] = 'abcdefg'
286
289
        self.assertEqual({1: 'abcdefg'}, c)