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

  • Committer: Jelmer Vernooij
  • Date: 2018-11-11 04:08:32 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181111040832-nsljjynzzwmznf3h
Run autopep8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_tree.py
83
83
    calls = []
84
84
 
85
85
    def compare(self, want_unchanged=False, specific_files=None,
86
 
        extra_trees=None, require_versioned=False, include_root=False,
87
 
        want_unversioned=False):
 
86
                extra_trees=None, require_versioned=False, include_root=False,
 
87
                want_unversioned=False):
88
88
        self.calls.append(
89
89
            ('compare', self.source, self.target, want_unchanged,
90
90
             specific_files, extra_trees, require_versioned,
115
115
                              'require', True)
116
116
            # pass in all optional arguments by keyword
117
117
            tree.changes_from(tree2,
118
 
                specific_files='specific',
119
 
                want_unchanged='unchanged',
120
 
                extra_trees='extra',
121
 
                require_versioned='require',
122
 
                include_root=True,
123
 
                want_unversioned=True,
124
 
                )
 
118
                              specific_files='specific',
 
119
                              want_unchanged='unchanged',
 
120
                              extra_trees='extra',
 
121
                              require_versioned='require',
 
122
                              include_root=True,
 
123
                              want_unversioned=True,
 
124
                              )
125
125
        finally:
126
126
            InterTree._optimisers = old_optimisers
127
127
        self.assertEqual(
128
128
            [
129
 
             ('compare', tree2, tree, False, None, None, False, False, False),
130
 
             ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
131
 
              'require', True, False),
132
 
             ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
133
 
              'require', True, True),
 
129
                ('compare', tree2, tree, False, None, None, False, False, False),
 
130
                ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
 
131
                    'require', True, False),
 
132
                ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
 
133
                    'require', True, True),
134
134
            ], RecordingOptimiser.calls)
135
135
 
136
136
    def test_changes_from_with_root(self):
149
149
        wt.add('known_file')
150
150
 
151
151
        self.assertRaises(errors.PathsNotVersionedError,
152
 
            wt.changes_from, wt.basis_tree(), wt, specific_files=['known_file',
153
 
            'unknown_file'], require_versioned=True)
 
152
                          wt.changes_from, wt.basis_tree(), wt, specific_files=['known_file',
 
153
                                                                                'unknown_file'], require_versioned=True)
154
154
 
155
155
        # we need to pass a known file with an unknown file to get this to
156
156
        # fail when expected.
157
157
        delta = wt.changes_from(wt.basis_tree(),
158
 
            specific_files=['known_file', 'unknown_file'],
159
 
            require_versioned=False)
 
158
                                specific_files=['known_file', 'unknown_file'],
 
159
                                require_versioned=False)
160
160
        self.assertEqual(len(delta.added), 1)
161
161
 
162
162
 
216
216
        else:
217
217
            self.assertIs(None, master_ie, 'master should not have an entry')
218
218
        self.assertEqual(len(exp_other_paths), len(other_values),
219
 
                            'Wrong number of other entries')
 
219
                         'Wrong number of other entries')
220
220
        other_paths = []
221
221
        other_file_ids = []
222
222
        for path, ie in other_values:
367
367
                                              second_tree])
368
368
        iterator = walker.iter_all()
369
369
        self.assertWalkerNext(u'', root_id, True, [u'', u'', u''], iterator)
370
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a', u'a', u'a'], iterator)
371
 
        self.assertWalkerNext(u'b', b'b-id', True, [u'b', u'b', u'b'], iterator)
372
 
        self.assertWalkerNext(u'c', b'c-id', False, [u'c', u'c', u'c'], iterator)
373
 
        self.assertWalkerNext(u'd', b'd-id', False, [None, u'd', u'd'], iterator)
374
 
        self.assertWalkerNext(u'e', b'e-id', False, [None, u'e', None], iterator)
 
370
        self.assertWalkerNext(u'a', b'a-id', True,
 
371
                              [u'a', u'a', u'a'], iterator)
 
372
        self.assertWalkerNext(u'b', b'b-id', True,
 
373
                              [u'b', u'b', u'b'], iterator)
 
374
        self.assertWalkerNext(u'c', b'c-id', False,
 
375
                              [u'c', u'c', u'c'], iterator)
 
376
        self.assertWalkerNext(u'd', b'd-id', False,
 
377
                              [None, u'd', u'd'], iterator)
 
378
        self.assertWalkerNext(u'e', b'e-id', False,
 
379
                              [None, u'e', None], iterator)
375
380
        self.assertRaises(StopIteration, next, iterator)
376
381
 
377
382
    def test_different_file_id_in_others(self):
404
409
 
405
410
    def assertLtByDirblock(self, lt_val, path1, path2):
406
411
        self.assertEqual(lt_val,
407
 
            _mod_tree.MultiWalker._lt_path_by_dirblock(path1, path2))
 
412
                         _mod_tree.MultiWalker._lt_path_by_dirblock(path1, path2))
408
413
 
409
414
    def test__lt_path_by_dirblock(self):
410
415
        # We only support Unicode strings at this point
411
416
        self.assertRaises(TypeError,
412
 
            _mod_tree.MultiWalker._lt_path_by_dirblock, b'', b'b')
 
417
                          _mod_tree.MultiWalker._lt_path_by_dirblock, b'', b'b')
413
418
        self.assertLtByDirblock(False, u'', u'')
414
419
        self.assertLtByDirblock(False, u'a', u'a')
415
420
        self.assertLtByDirblock(False, u'a/b', u'a/b')
472
477
        self.build_tree(['tree/b'])
473
478
        tree.add(['b'])
474
479
        self.assertEqual(
475
 
                'b',
476
 
                get_canonical_path(tree, 'b', lambda x: x.lower()))
 
480
            'b',
 
481
            get_canonical_path(tree, 'b', lambda x: x.lower()))
477
482
        self.assertEqual(
478
 
                'b',
479
 
                get_canonical_path(tree, 'B', lambda x: x.lower()))
 
483
            'b',
 
484
            get_canonical_path(tree, 'B', lambda x: x.lower()))
480
485
 
481
486
    def test_nonexistant_preserves_case(self):
482
487
        tree = self.make_branch_and_tree('tree')
483
488
        self.assertEqual(
484
 
                'b',
485
 
                get_canonical_path(tree, 'b', lambda x: x.lower()))
 
489
            'b',
 
490
            get_canonical_path(tree, 'b', lambda x: x.lower()))
486
491
        self.assertEqual(
487
 
                'B',
488
 
                get_canonical_path(tree, 'B', lambda x: x.lower()))
 
492
            'B',
 
493
            get_canonical_path(tree, 'B', lambda x: x.lower()))
489
494
 
490
495
    def test_in_directory_with_case(self):
491
496
        tree = self.make_branch_and_tree('tree')
492
497
        self.build_tree(['tree/a/', 'tree/a/b'])
493
498
        tree.add(['a', 'a/b'])
494
499
        self.assertEqual(
495
 
                'a/b',
496
 
                get_canonical_path(tree, 'a/b', lambda x: x.lower()))
497
 
        self.assertEqual(
498
 
                'a/b',
499
 
                get_canonical_path(tree, 'A/B', lambda x: x.lower()))
500
 
        self.assertEqual(
501
 
                'a/b',
502
 
                get_canonical_path(tree, 'A/b', lambda x: x.lower()))
503
 
        self.assertEqual(
504
 
                'a/C',
505
 
                get_canonical_path(tree, 'A/C', lambda x: x.lower()))
 
500
            'a/b',
 
501
            get_canonical_path(tree, 'a/b', lambda x: x.lower()))
 
502
        self.assertEqual(
 
503
            'a/b',
 
504
            get_canonical_path(tree, 'A/B', lambda x: x.lower()))
 
505
        self.assertEqual(
 
506
            'a/b',
 
507
            get_canonical_path(tree, 'A/b', lambda x: x.lower()))
 
508
        self.assertEqual(
 
509
            'a/C',
 
510
            get_canonical_path(tree, 'A/C', lambda x: x.lower()))