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

  • Committer: Jelmer Vernooij
  • Date: 2019-03-04 00:16:27 UTC
  • mfrom: (7293 work)
  • mto: This revision was merged to the branch mainline in revision 7318.
  • Revision ID: jelmer@jelmer.uk-20190304001627-v6u7o6pf97tukhek
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test__annotator.py
31
31
def load_tests(loader, standard_tests, pattern):
32
32
    """Parameterize tests for all versions of groupcompress."""
33
33
    suite, _ = tests.permute_tests_for_extension(standard_tests, loader,
34
 
        'breezy._annotator_py', 'breezy._annotator_pyx')
 
34
                                                 'breezy._annotator_py', 'breezy._annotator_pyx')
35
35
    return suite
36
36
 
37
37
 
38
38
class TestAnnotator(tests.TestCaseWithMemoryTransport):
39
39
 
40
 
    module = None # Set by load_tests
 
40
    module = None  # Set by load_tests
41
41
 
42
42
    fa_key = (b'f-id', b'a-id')
43
43
    fb_key = (b'f-id', b'b-id')
151
151
 
152
152
    def test_annotate_simple(self):
153
153
        self.make_simple_text()
154
 
        self.assertAnnotateEqual([(self.fa_key,)]*2, self.fa_key)
 
154
        self.assertAnnotateEqual([(self.fa_key,)] * 2, self.fa_key)
155
155
        self.assertAnnotateEqual([(self.fa_key,), (self.fb_key,)], self.fb_key)
156
156
 
157
157
    def test_annotate_merge_text(self):
180
180
        self.make_simple_text()
181
181
        self.assertEqual([(self.fa_key, b'simple\n'),
182
182
                          (self.fa_key, b'content\n'),
183
 
                         ], self.ann.annotate_flat(self.fa_key))
 
183
                          ], self.ann.annotate_flat(self.fa_key))
184
184
        self.assertEqual([(self.fa_key, b'simple\n'),
185
185
                          (self.fb_key, b'new content\n'),
186
 
                         ], self.ann.annotate_flat(self.fb_key))
 
186
                          ], self.ann.annotate_flat(self.fb_key))
187
187
 
188
188
    def test_annotate_flat_merge_and_restored_text(self):
189
189
        self.make_merge_and_restored_text()
190
190
        # fc is a simple dominator of fa
191
191
        self.assertEqual([(self.fa_key, b'simple\n'),
192
192
                          (self.fc_key, b'content\n'),
193
 
                         ], self.ann.annotate_flat(self.fd_key))
 
193
                          ], self.ann.annotate_flat(self.fd_key))
194
194
 
195
195
    def test_annotate_common_merge_text(self):
196
196
        self.make_common_merge_text()
198
198
        # and b'b-id' comes before b'c-id'
199
199
        self.assertEqual([(self.fa_key, b'simple\n'),
200
200
                          (self.fb_key, b'new content\n'),
201
 
                         ], self.ann.annotate_flat(self.fd_key))
 
201
                          ], self.ann.annotate_flat(self.fd_key))
202
202
 
203
203
    def test_annotate_many_way_common_merge_text(self):
204
204
        self.make_many_way_common_merge_text()
205
205
        self.assertEqual([(self.fa_key, b'simple\n'),
206
 
                         (self.fb_key, b'new content\n')],
 
206
                          (self.fb_key, b'new content\n')],
207
207
                         self.ann.annotate_flat(self.ff_key))
208
208
 
209
209
    def test_annotate_flat_respects_break_ann_tie(self):
210
210
        seen = set()
 
211
 
211
212
        def custom_tiebreaker(annotated_lines):
212
213
            self.assertEqual(2, len(annotated_lines))
213
214
            left = annotated_lines[0]
226
227
        self.overrideAttr(annotate, '_break_annotation_tie', custom_tiebreaker)
227
228
        self.make_many_way_common_merge_text()
228
229
        self.assertEqual([(self.fa_key, b'simple\n'),
229
 
                         (self.fe_key, b'new content\n')],
 
230
                          (self.fe_key, b'new content\n')],
230
231
                         self.ann.annotate_flat(self.ff_key))
231
232
        # Calls happen in set iteration order but should keys should be seen
232
233
        self.assertEqual({self.fb_key, self.fc_key, self.fe_key}, seen)
244
245
        keys, ann_keys = self.ann._get_needed_keys(self.ff_key)
245
246
        self.assertEqual([self.fa_key, self.fb_key, self.fc_key,
246
247
                          self.fd_key, self.fe_key, self.ff_key,
247
 
                         ], sorted(keys))
 
248
                          ], sorted(keys))
248
249
        self.assertEqual({self.fa_key: 3,
249
250
                          self.fb_key: 1,
250
251
                          self.fc_key: 1,
251
252
                          self.fd_key: 1,
252
253
                          self.fe_key: 1,
253
254
                          self.ff_key: 1,
254
 
                         }, self.ann._num_needed_children)
 
255
                          }, self.ann._num_needed_children)
255
256
        self.assertEqual(set(), ann_keys)
256
257
 
257
258
    def test_needed_keys_with_special_text(self):
263
264
        keys, ann_keys = self.ann._get_needed_keys(spec_key)
264
265
        self.assertEqual([self.fa_key, self.fb_key, self.fc_key,
265
266
                          self.fd_key, self.fe_key,
266
 
                         ], sorted(keys))
 
267
                          ], sorted(keys))
267
268
        self.assertEqual([spec_key], sorted(ann_keys))
268
269
 
269
270
    def test_needed_keys_with_parent_texts(self):
292
293
        self.assertEqual({self.fd_key: 1,
293
294
                          self.fe_key: 1,
294
295
                          self.ff_key: 1,
295
 
                         }, self.ann._num_needed_children)
 
296
                          }, self.ann._num_needed_children)
296
297
        self.assertEqual([], sorted(ann_keys))
297
298
 
298
299
    def test_record_annotation_removes_texts(self):
306
307
                          self.fd_key: 1,
307
308
                          self.fe_key: 1,
308
309
                          self.ff_key: 1,
309
 
                         }, self.ann._num_needed_children)
 
310
                          }, self.ann._num_needed_children)
310
311
        self.assertEqual([self.fa_key, self.fb_key, self.fc_key,
311
312
                          self.fd_key, self.fe_key, self.ff_key,
312
 
                         ], sorted(self.ann._text_cache.keys()))
 
313
                          ], sorted(self.ann._text_cache.keys()))
313
314
        self.ann._record_annotation(self.fa_key, [], [])
314
315
        self.ann._record_annotation(self.fb_key, [self.fa_key], [])
315
316
        self.assertEqual({self.fa_key: 2,
318
319
                          self.fd_key: 1,
319
320
                          self.fe_key: 1,
320
321
                          self.ff_key: 1,
321
 
                         }, self.ann._num_needed_children)
 
322
                          }, self.ann._num_needed_children)
322
323
        self.assertTrue(self.fa_key in self.ann._text_cache)
323
324
        self.assertTrue(self.fa_key in self.ann._annotations_cache)
324
325
        self.ann._record_annotation(self.fc_key, [self.fa_key], [])
325
 
        self.ann._record_annotation(self.fd_key, [self.fb_key, self.fc_key], [])
 
326
        self.ann._record_annotation(
 
327
            self.fd_key, [self.fb_key, self.fc_key], [])
326
328
        self.assertEqual({self.fa_key: 1,
327
329
                          self.fb_key: 0,
328
330
                          self.fc_key: 0,
329
331
                          self.fd_key: 1,
330
332
                          self.fe_key: 1,
331
333
                          self.ff_key: 1,
332
 
                         }, self.ann._num_needed_children)
 
334
                          }, self.ann._num_needed_children)
333
335
        self.assertTrue(self.fa_key in self.ann._text_cache)
334
336
        self.assertTrue(self.fa_key in self.ann._annotations_cache)
335
337
        self.assertFalse(self.fb_key in self.ann._text_cache)
360
362
        self.assertAnnotateEqual([(self.fa_key,),
361
363
                                  (self.fb_key, self.fc_key, self.fe_key),
362
364
                                  (spec_key,),
363
 
                                 ], spec_key,
 
365
                                  ], spec_key,
364
366
                                 exp_text=spec_text)
365
367
 
366
368
    def test_no_graph(self):
367
369
        self.make_no_graph_texts()
368
370
        self.assertAnnotateEqual([(self.fa_key,),
369
371
                                  (self.fa_key,),
370
 
                                 ], self.fa_key)
 
372
                                  ], self.fa_key)
371
373
        self.assertAnnotateEqual([(self.fb_key,),
372
374
                                  (self.fb_key,),
373
 
                                 ], self.fb_key)
 
375
                                  ], self.fb_key)