/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: 2019-02-03 01:42:11 UTC
  • mto: This revision was merged to the branch mainline in revision 7267.
  • Revision ID: jelmer@jelmer.uk-20190203014211-poj1fv922sejfsb4
Don't require that short git shas have an even number of characters.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_tree.py
1
 
# Copyright (C) 2006, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-2009, 2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests for Tree and InterTree."""
18
18
 
19
 
from bzrlib import (
 
19
from breezy import (
20
20
    errors,
21
21
    revision,
22
 
    tests,
23
22
    tree as _mod_tree,
24
23
    )
25
 
from bzrlib.tests import TestCaseWithTransport
26
 
from bzrlib.tree import InterTree
 
24
from breezy.tests import (
 
25
    TestCase,
 
26
    TestCaseWithTransport,
 
27
    )
 
28
from breezy.tree import (
 
29
    FileTimestampUnavailable,
 
30
    InterTree,
 
31
    find_previous_paths,
 
32
    get_canonical_path,
 
33
    )
 
34
 
 
35
 
 
36
class TestErrors(TestCase):
 
37
 
 
38
    def test_file_timestamp_unavailable(self):
 
39
        e = FileTimestampUnavailable("/path/foo")
 
40
        self.assertEqual("The filestamp for /path/foo is not available.",
 
41
                         str(e))
27
42
 
28
43
 
29
44
class TestInterTree(TestCaseWithTransport):
68
83
    calls = []
69
84
 
70
85
    def compare(self, want_unchanged=False, specific_files=None,
71
 
        extra_trees=None, require_versioned=False, include_root=False,
72
 
        want_unversioned=False):
 
86
                extra_trees=None, require_versioned=False, include_root=False,
 
87
                want_unversioned=False):
73
88
        self.calls.append(
74
89
            ('compare', self.source, self.target, want_unchanged,
75
90
             specific_files, extra_trees, require_versioned,
100
115
                              'require', True)
101
116
            # pass in all optional arguments by keyword
102
117
            tree.changes_from(tree2,
103
 
                specific_files='specific',
104
 
                want_unchanged='unchanged',
105
 
                extra_trees='extra',
106
 
                require_versioned='require',
107
 
                include_root=True,
108
 
                want_unversioned=True,
109
 
                )
 
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
                              )
110
125
        finally:
111
126
            InterTree._optimisers = old_optimisers
112
127
        self.assertEqual(
113
128
            [
114
 
             ('compare', tree2, tree, False, None, None, False, False, False),
115
 
             ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
116
 
              'require', True, False),
117
 
             ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
118
 
              'require', True, True),
 
129
                ('compare', tree2, tree, False, None, None, False, False,
 
130
                    False),
 
131
                ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
 
132
                    'require', True, False),
 
133
                ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
 
134
                    'require', True, True),
119
135
            ], RecordingOptimiser.calls)
120
136
 
121
137
    def test_changes_from_with_root(self):
133
149
        self.build_tree(['known_file', 'unknown_file'])
134
150
        wt.add('known_file')
135
151
 
136
 
        self.assertRaises(errors.PathsNotVersionedError,
137
 
            wt.changes_from, wt.basis_tree(), wt, specific_files=['known_file',
138
 
            'unknown_file'], require_versioned=True)
 
152
        self.assertRaises(
 
153
            errors.PathsNotVersionedError,
 
154
            wt.changes_from, wt.basis_tree(), wt,
 
155
            specific_files=['known_file', 'unknown_file'],
 
156
            require_versioned=True)
139
157
 
140
158
        # we need to pass a known file with an unknown file to get this to
141
159
        # fail when expected.
142
160
        delta = wt.changes_from(wt.basis_tree(),
143
 
            specific_files=['known_file', 'unknown_file'] ,
144
 
            require_versioned=False)
 
161
                                specific_files=['known_file', 'unknown_file'],
 
162
                                require_versioned=False)
145
163
        self.assertEqual(len(delta.added), 1)
146
164
 
147
165
 
169
187
    def test__step_one(self):
170
188
        tree = self.make_branch_and_tree('tree')
171
189
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
172
 
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
 
190
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
173
191
 
174
192
        iterator = tree.iter_entries_by_dir()
175
193
        tree.lock_read()
177
195
 
178
196
        root_id = tree.path2id('')
179
197
        self.assertStepOne(True, '', root_id, iterator)
180
 
        self.assertStepOne(True, 'a', 'a-id', iterator)
181
 
        self.assertStepOne(True, 'b', 'b-id', iterator)
182
 
        self.assertStepOne(True, 'b/c', 'c-id', iterator)
 
198
        self.assertStepOne(True, 'a', b'a-id', iterator)
 
199
        self.assertStepOne(True, 'b', b'b-id', iterator)
 
200
        self.assertStepOne(True, 'b/c', b'c-id', iterator)
183
201
        self.assertStepOne(False, None, None, iterator)
184
202
        self.assertStepOne(False, None, None, iterator)
185
203
 
193
211
        :param exp_other_paths: A list of other_path values.
194
212
        :param iterator: The iterator to step
195
213
        """
196
 
        path, file_id, master_ie, other_values = iterator.next()
 
214
        path, file_id, master_ie, other_values = next(iterator)
197
215
        self.assertEqual((exp_path, exp_file_id), (path, file_id),
198
216
                         'Master entry did not match')
199
217
        if master_has_node:
201
219
        else:
202
220
            self.assertIs(None, master_ie, 'master should not have an entry')
203
221
        self.assertEqual(len(exp_other_paths), len(other_values),
204
 
                            'Wrong number of other entries')
 
222
                         'Wrong number of other entries')
205
223
        other_paths = []
206
224
        other_file_ids = []
207
225
        for path, ie in other_values:
233
251
    def test_simple_stepping(self):
234
252
        tree = self.make_branch_and_tree('tree')
235
253
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
236
 
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
 
254
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
237
255
 
238
 
        tree.commit('first', rev_id='first-rev-id')
 
256
        tree.commit('first', rev_id=b'first-rev-id')
239
257
 
240
258
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
241
259
 
242
260
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
243
261
        iterator = walker.iter_all()
244
262
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
245
 
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
246
 
        self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
247
 
        self.assertWalkerNext(u'b/c', 'c-id', True, [u'b/c'], iterator)
248
 
        self.assertRaises(StopIteration, iterator.next)
 
263
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
264
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
 
265
        self.assertWalkerNext(u'b/c', b'c-id', True, [u'b/c'], iterator)
 
266
        self.assertRaises(StopIteration, next, iterator)
249
267
 
250
268
    def test_master_has_extra(self):
251
269
        tree = self.make_branch_and_tree('tree')
252
270
        self.build_tree(['tree/a', 'tree/b/', 'tree/c', 'tree/d'])
253
 
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
254
 
 
255
 
        tree.commit('first', rev_id='first-rev-id')
256
 
 
257
 
        tree.add(['c'], ['c-id'])
 
271
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
 
272
 
 
273
        tree.commit('first', rev_id=b'first-rev-id')
 
274
 
 
275
        tree.add(['c'], [b'c-id'])
258
276
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
259
277
 
260
278
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
261
279
        iterator = walker.iter_all()
262
280
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
263
 
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
264
 
        self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
265
 
        self.assertWalkerNext(u'c', 'c-id', True, [None], iterator)
266
 
        self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
267
 
        self.assertRaises(StopIteration, iterator.next)
 
281
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
282
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
 
283
        self.assertWalkerNext(u'c', b'c-id', True, [None], iterator)
 
284
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
 
285
        self.assertRaises(StopIteration, next, iterator)
268
286
 
269
287
    def test_master_renamed_to_earlier(self):
270
288
        """The record is still present, it just shows up early."""
271
289
        tree = self.make_branch_and_tree('tree')
272
290
        self.build_tree(['tree/a', 'tree/c', 'tree/d'])
273
 
        tree.add(['a', 'c', 'd'], ['a-id', 'c-id', 'd-id'])
274
 
        tree.commit('first', rev_id='first-rev-id')
 
291
        tree.add(['a', 'c', 'd'], [b'a-id', b'c-id', b'd-id'])
 
292
        tree.commit('first', rev_id=b'first-rev-id')
275
293
        tree.rename_one('d', 'b')
276
294
 
277
295
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
279
297
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
280
298
        iterator = walker.iter_all()
281
299
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
282
 
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
283
 
        self.assertWalkerNext(u'b', 'd-id', True, [u'd'], iterator)
284
 
        self.assertWalkerNext(u'c', 'c-id', True, [u'c'], iterator)
285
 
        self.assertRaises(StopIteration, iterator.next)
 
300
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
301
        self.assertWalkerNext(u'b', b'd-id', True, [u'd'], iterator)
 
302
        self.assertWalkerNext(u'c', b'c-id', True, [u'c'], iterator)
 
303
        self.assertRaises(StopIteration, next, iterator)
286
304
 
287
305
    def test_master_renamed_to_later(self):
288
306
        tree = self.make_branch_and_tree('tree')
289
307
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
290
 
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
291
 
        tree.commit('first', rev_id='first-rev-id')
 
308
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
 
309
        tree.commit('first', rev_id=b'first-rev-id')
292
310
        tree.rename_one('b', 'e')
293
311
 
294
312
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
296
314
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
297
315
        iterator = walker.iter_all()
298
316
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
299
 
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
300
 
        self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
301
 
        self.assertWalkerNext(u'e', 'b-id', True, [u'b'], iterator)
302
 
        self.assertRaises(StopIteration, iterator.next)
 
317
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
318
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
 
319
        self.assertWalkerNext(u'e', b'b-id', True, [u'b'], iterator)
 
320
        self.assertRaises(StopIteration, next, iterator)
303
321
 
304
322
    def test_other_extra_in_middle(self):
305
323
        tree = self.make_branch_and_tree('tree')
306
324
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
307
 
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
308
 
        tree.commit('first', rev_id='first-rev-id')
 
325
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
 
326
        tree.commit('first', rev_id=b'first-rev-id')
309
327
        tree.remove(['b'])
310
328
 
311
329
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
312
330
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
313
331
        iterator = walker.iter_all()
314
332
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
315
 
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
316
 
        self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
317
 
        self.assertWalkerNext(u'b', 'b-id', False, [u'b'], iterator)
318
 
        self.assertRaises(StopIteration, iterator.next)
 
333
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
334
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
 
335
        self.assertWalkerNext(u'b', b'b-id', False, [u'b'], iterator)
 
336
        self.assertRaises(StopIteration, next, iterator)
319
337
 
320
338
    def test_other_extra_at_end(self):
321
339
        tree = self.make_branch_and_tree('tree')
322
340
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
323
 
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
324
 
        tree.commit('first', rev_id='first-rev-id')
 
341
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
 
342
        tree.commit('first', rev_id=b'first-rev-id')
325
343
        tree.remove(['d'])
326
344
 
327
345
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
328
346
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
329
347
        iterator = walker.iter_all()
330
348
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
331
 
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
332
 
        self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
333
 
        self.assertWalkerNext(u'd', 'd-id', False, [u'd'], iterator)
334
 
        self.assertRaises(StopIteration, iterator.next)
 
349
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
350
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
 
351
        self.assertWalkerNext(u'd', b'd-id', False, [u'd'], iterator)
 
352
        self.assertRaises(StopIteration, next, iterator)
335
353
 
336
354
    def test_others_extra_at_end(self):
337
355
        tree = self.make_branch_and_tree('tree')
338
356
        self.build_tree(['tree/a', 'tree/b', 'tree/c', 'tree/d', 'tree/e'])
339
357
        tree.add(['a', 'b', 'c', 'd', 'e'],
340
 
                 ['a-id', 'b-id', 'c-id', 'd-id', 'e-id'])
341
 
        tree.commit('first', rev_id='first-rev-id')
 
358
                 [b'a-id', b'b-id', b'c-id', b'd-id', b'e-id'])
 
359
        tree.commit('first', rev_id=b'first-rev-id')
342
360
        tree.remove(['e'])
343
 
        tree.commit('second', rev_id='second-rev-id')
 
361
        tree.commit('second', rev_id=b'second-rev-id')
344
362
        tree.remove(['d'])
345
 
        tree.commit('third', rev_id='third-rev-id')
 
363
        tree.commit('third', rev_id=b'third-rev-id')
346
364
        tree.remove(['c'])
347
365
 
348
366
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
349
 
        first_tree = tree.branch.repository.revision_tree('first-rev-id')
350
 
        second_tree = tree.branch.repository.revision_tree('second-rev-id')
 
367
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
 
368
        second_tree = tree.branch.repository.revision_tree(b'second-rev-id')
351
369
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree,
352
370
                                              second_tree])
353
371
        iterator = walker.iter_all()
354
372
        self.assertWalkerNext(u'', root_id, True, [u'', u'', u''], iterator)
355
 
        self.assertWalkerNext(u'a', 'a-id', True, [u'a', u'a', u'a'], iterator)
356
 
        self.assertWalkerNext(u'b', 'b-id', True, [u'b', u'b', u'b'], iterator)
357
 
        self.assertWalkerNext(u'c', 'c-id', False, [u'c', u'c', u'c'], iterator)
358
 
        self.assertWalkerNext(u'd', 'd-id', False, [None, u'd', u'd'], iterator)
359
 
        self.assertWalkerNext(u'e', 'e-id', False, [None, u'e', None], iterator)
360
 
        self.assertRaises(StopIteration, iterator.next)
 
373
        self.assertWalkerNext(u'a', b'a-id', True,
 
374
                              [u'a', u'a', u'a'], iterator)
 
375
        self.assertWalkerNext(u'b', b'b-id', True,
 
376
                              [u'b', u'b', u'b'], iterator)
 
377
        self.assertWalkerNext(u'c', b'c-id', False,
 
378
                              [u'c', u'c', u'c'], iterator)
 
379
        self.assertWalkerNext(u'd', b'd-id', False,
 
380
                              [None, u'd', u'd'], iterator)
 
381
        self.assertWalkerNext(u'e', b'e-id', False,
 
382
                              [None, u'e', None], iterator)
 
383
        self.assertRaises(StopIteration, next, iterator)
361
384
 
362
385
    def test_different_file_id_in_others(self):
363
386
        tree = self.make_branch_and_tree('tree')
364
387
        self.build_tree(['tree/a', 'tree/b', 'tree/c/'])
365
 
        tree.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id'])
366
 
        tree.commit('first', rev_id='first-rev-id')
 
388
        tree.add(['a', 'b', 'c'], [b'a-id', b'b-id', b'c-id'])
 
389
        tree.commit('first', rev_id=b'first-rev-id')
367
390
 
368
391
        tree.rename_one('b', 'c/d')
369
392
        self.build_tree(['tree/b'])
370
 
        tree.add(['b'], ['b2-id'])
371
 
        tree.commit('second', rev_id='second-rev-id')
 
393
        tree.add(['b'], [b'b2-id'])
 
394
        tree.commit('second', rev_id=b'second-rev-id')
372
395
 
373
396
        tree.rename_one('a', 'c/e')
374
397
        self.build_tree(['tree/a'])
375
 
        tree.add(['a'], ['a2-id'])
 
398
        tree.add(['a'], [b'a2-id'])
376
399
 
377
400
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
378
 
        first_tree = tree.branch.repository.revision_tree('first-rev-id')
 
401
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
379
402
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree])
380
403
 
381
404
        iterator = walker.iter_all()
382
405
        self.assertWalkerNext(u'', root_id, True, [u'', u''], iterator)
383
 
        self.assertWalkerNext(u'a', 'a2-id', True, [None, None], iterator)
384
 
        self.assertWalkerNext(u'b', 'b2-id', True, [u'b', None], iterator)
385
 
        self.assertWalkerNext(u'c', 'c-id', True, [u'c', u'c'], iterator)
386
 
        self.assertWalkerNext(u'c/d', 'b-id', True, [u'c/d', u'b'], iterator)
387
 
        self.assertWalkerNext(u'c/e', 'a-id', True, [u'a', u'a'], iterator)
388
 
        self.assertRaises(StopIteration, iterator.next)
389
 
 
390
 
    def assertCmpByDirblock(self, cmp_val, path1, path2):
391
 
        self.assertEqual(cmp_val,
392
 
            _mod_tree.MultiWalker._cmp_path_by_dirblock(path1, path2))
393
 
 
394
 
    def test__cmp_path_by_dirblock(self):
 
406
        self.assertWalkerNext(u'a', b'a2-id', True, [None, None], iterator)
 
407
        self.assertWalkerNext(u'b', b'b2-id', True, [u'b', None], iterator)
 
408
        self.assertWalkerNext(u'c', b'c-id', True, [u'c', u'c'], iterator)
 
409
        self.assertWalkerNext(u'c/d', b'b-id', True, [u'c/d', u'b'], iterator)
 
410
        self.assertWalkerNext(u'c/e', b'a-id', True, [u'a', u'a'], iterator)
 
411
        self.assertRaises(StopIteration, next, iterator)
 
412
 
 
413
    def assertLtByDirblock(self, lt_val, path1, path2):
 
414
        self.assertEqual(
 
415
            lt_val, _mod_tree.MultiWalker._lt_path_by_dirblock(path1, path2))
 
416
 
 
417
    def test__lt_path_by_dirblock(self):
395
418
        # We only support Unicode strings at this point
396
 
        self.assertRaises(TypeError,
397
 
            _mod_tree.MultiWalker._cmp_path_by_dirblock, '', 'b')
398
 
        self.assertCmpByDirblock(0, u'', u'')
399
 
        self.assertCmpByDirblock(0, u'a', u'a')
400
 
        self.assertCmpByDirblock(0, u'a/b', u'a/b')
401
 
        self.assertCmpByDirblock(0, u'a/b/c', u'a/b/c')
402
 
        self.assertCmpByDirblock(1, u'a-a', u'a')
403
 
        self.assertCmpByDirblock(-1, u'a-a', u'a/a')
404
 
        self.assertCmpByDirblock(-1, u'a=a', u'a/a')
405
 
        self.assertCmpByDirblock(1, u'a-a/a', u'a/a')
406
 
        self.assertCmpByDirblock(1, u'a=a/a', u'a/a')
407
 
        self.assertCmpByDirblock(1, u'a-a/a', u'a/a/a')
408
 
        self.assertCmpByDirblock(1, u'a=a/a', u'a/a/a')
409
 
        self.assertCmpByDirblock(1, u'a-a/a/a', u'a/a/a')
410
 
        self.assertCmpByDirblock(1, u'a=a/a/a', u'a/a/a')
 
419
        self.assertRaises(
 
420
            TypeError, _mod_tree.MultiWalker._lt_path_by_dirblock, b'', b'b')
 
421
        self.assertLtByDirblock(False, u'', u'')
 
422
        self.assertLtByDirblock(False, u'a', u'a')
 
423
        self.assertLtByDirblock(False, u'a/b', u'a/b')
 
424
        self.assertLtByDirblock(False, u'a/b/c', u'a/b/c')
 
425
        self.assertLtByDirblock(False, u'a-a', u'a')
 
426
        self.assertLtByDirblock(True, u'a-a', u'a/a')
 
427
        self.assertLtByDirblock(True, u'a=a', u'a/a')
 
428
        self.assertLtByDirblock(False, u'a-a/a', u'a/a')
 
429
        self.assertLtByDirblock(False, u'a=a/a', u'a/a')
 
430
        self.assertLtByDirblock(False, u'a-a/a', u'a/a/a')
 
431
        self.assertLtByDirblock(False, u'a=a/a', u'a/a/a')
 
432
        self.assertLtByDirblock(False, u'a-a/a/a', u'a/a/a')
 
433
        self.assertLtByDirblock(False, u'a=a/a/a', u'a/a/a')
411
434
 
412
435
    def assertPathToKey(self, expected, path):
413
436
        self.assertEqual(expected, _mod_tree.MultiWalker._path_to_key(path))
417
440
        self.assertPathToKey(([u''], u'a'), u'a')
418
441
        self.assertPathToKey(([u'a'], u'b'), u'a/b')
419
442
        self.assertPathToKey(([u'a', u'b'], u'c'), u'a/b/c')
 
443
 
 
444
 
 
445
class FindPreviousPathsTests(TestCaseWithTransport):
 
446
 
 
447
    def test_new(self):
 
448
        tree = self.make_branch_and_tree('tree')
 
449
        self.build_tree(['tree/b'])
 
450
        tree.add(['b'])
 
451
        revid1 = tree.commit('first')
 
452
        tree1 = tree.branch.repository.revision_tree(revid1)
 
453
 
 
454
        tree0 = tree.branch.repository.revision_tree(revision.NULL_REVISION)
 
455
 
 
456
        self.assertEqual({'b': None}, find_previous_paths(tree1, tree0, ['b']))
 
457
 
 
458
    def test_find_previous_paths(self):
 
459
        tree = self.make_branch_and_tree('tree')
 
460
        self.build_tree(['tree/b'])
 
461
        tree.add(['b'])
 
462
        revid1 = tree.commit('first')
 
463
        tree1 = tree.branch.repository.revision_tree(revid1)
 
464
 
 
465
        tree.rename_one('b', 'c')
 
466
        self.build_tree(['tree/b'])
 
467
        tree.add(['b'])
 
468
        revid2 = tree.commit('second')
 
469
        tree2 = tree.branch.repository.revision_tree(revid2)
 
470
 
 
471
        self.assertEqual({'c': 'b', 'b': None},
 
472
                         find_previous_paths(tree2, tree1, ['b', 'c']))
 
473
 
 
474
 
 
475
class GetCanonicalPath(TestCaseWithTransport):
 
476
 
 
477
    def test_existing_case(self):
 
478
        # Test that we can find a file from a path with different case
 
479
        tree = self.make_branch_and_tree('tree')
 
480
        self.build_tree(['tree/b'])
 
481
        tree.add(['b'])
 
482
        self.assertEqual(
 
483
            'b',
 
484
            get_canonical_path(tree, 'b', lambda x: x.lower()))
 
485
        self.assertEqual(
 
486
            'b',
 
487
            get_canonical_path(tree, 'B', lambda x: x.lower()))
 
488
 
 
489
    def test_nonexistant_preserves_case(self):
 
490
        tree = self.make_branch_and_tree('tree')
 
491
        self.assertEqual(
 
492
            'b',
 
493
            get_canonical_path(tree, 'b', lambda x: x.lower()))
 
494
        self.assertEqual(
 
495
            'B',
 
496
            get_canonical_path(tree, 'B', lambda x: x.lower()))
 
497
 
 
498
    def test_in_directory_with_case(self):
 
499
        tree = self.make_branch_and_tree('tree')
 
500
        self.build_tree(['tree/a/', 'tree/a/b'])
 
501
        tree.add(['a', 'a/b'])
 
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/b',
 
510
            get_canonical_path(tree, 'A/b', lambda x: x.lower()))
 
511
        self.assertEqual(
 
512
            'a/C',
 
513
            get_canonical_path(tree, 'A/C', lambda x: x.lower()))