/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 07:18:33 UTC
  • mfrom: (7141.3.3 fix1799482)
  • Revision ID: breezy.the.bot@gmail.com-20181116071833-e01b0833f3hkc3et
Report correct paths when running "brz add" in git repositories.

Merged from https://code.launchpad.net/~jelmer/brz/fix1799482/+merge/357734

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):
140
155
        # we need to pass a known file with an unknown file to get this to
141
156
        # fail when expected.
142
157
        delta = wt.changes_from(wt.basis_tree(),
143
 
            specific_files=['known_file', 'unknown_file'] ,
 
158
            specific_files=['known_file', 'unknown_file'],
144
159
            require_versioned=False)
145
160
        self.assertEqual(len(delta.added), 1)
146
161
 
169
184
    def test__step_one(self):
170
185
        tree = self.make_branch_and_tree('tree')
171
186
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
172
 
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
 
187
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
173
188
 
174
189
        iterator = tree.iter_entries_by_dir()
175
190
        tree.lock_read()
177
192
 
178
193
        root_id = tree.path2id('')
179
194
        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)
 
195
        self.assertStepOne(True, 'a', b'a-id', iterator)
 
196
        self.assertStepOne(True, 'b', b'b-id', iterator)
 
197
        self.assertStepOne(True, 'b/c', b'c-id', iterator)
183
198
        self.assertStepOne(False, None, None, iterator)
184
199
        self.assertStepOne(False, None, None, iterator)
185
200
 
193
208
        :param exp_other_paths: A list of other_path values.
194
209
        :param iterator: The iterator to step
195
210
        """
196
 
        path, file_id, master_ie, other_values = iterator.next()
 
211
        path, file_id, master_ie, other_values = next(iterator)
197
212
        self.assertEqual((exp_path, exp_file_id), (path, file_id),
198
213
                         'Master entry did not match')
199
214
        if master_has_node:
233
248
    def test_simple_stepping(self):
234
249
        tree = self.make_branch_and_tree('tree')
235
250
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
236
 
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
 
251
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
237
252
 
238
 
        tree.commit('first', rev_id='first-rev-id')
 
253
        tree.commit('first', rev_id=b'first-rev-id')
239
254
 
240
255
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
241
256
 
242
257
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
243
258
        iterator = walker.iter_all()
244
259
        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)
 
260
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
261
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
 
262
        self.assertWalkerNext(u'b/c', b'c-id', True, [u'b/c'], iterator)
 
263
        self.assertRaises(StopIteration, next, iterator)
249
264
 
250
265
    def test_master_has_extra(self):
251
266
        tree = self.make_branch_and_tree('tree')
252
267
        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'])
 
268
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
 
269
 
 
270
        tree.commit('first', rev_id=b'first-rev-id')
 
271
 
 
272
        tree.add(['c'], [b'c-id'])
258
273
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
259
274
 
260
275
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
261
276
        iterator = walker.iter_all()
262
277
        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)
 
278
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
279
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
 
280
        self.assertWalkerNext(u'c', b'c-id', True, [None], iterator)
 
281
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
 
282
        self.assertRaises(StopIteration, next, iterator)
268
283
 
269
284
    def test_master_renamed_to_earlier(self):
270
285
        """The record is still present, it just shows up early."""
271
286
        tree = self.make_branch_and_tree('tree')
272
287
        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')
 
288
        tree.add(['a', 'c', 'd'], [b'a-id', b'c-id', b'd-id'])
 
289
        tree.commit('first', rev_id=b'first-rev-id')
275
290
        tree.rename_one('d', 'b')
276
291
 
277
292
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
279
294
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
280
295
        iterator = walker.iter_all()
281
296
        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)
 
297
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
298
        self.assertWalkerNext(u'b', b'd-id', True, [u'd'], iterator)
 
299
        self.assertWalkerNext(u'c', b'c-id', True, [u'c'], iterator)
 
300
        self.assertRaises(StopIteration, next, iterator)
286
301
 
287
302
    def test_master_renamed_to_later(self):
288
303
        tree = self.make_branch_and_tree('tree')
289
304
        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')
 
305
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
 
306
        tree.commit('first', rev_id=b'first-rev-id')
292
307
        tree.rename_one('b', 'e')
293
308
 
294
309
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
296
311
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
297
312
        iterator = walker.iter_all()
298
313
        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)
 
314
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
315
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
 
316
        self.assertWalkerNext(u'e', b'b-id', True, [u'b'], iterator)
 
317
        self.assertRaises(StopIteration, next, iterator)
303
318
 
304
319
    def test_other_extra_in_middle(self):
305
320
        tree = self.make_branch_and_tree('tree')
306
321
        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')
 
322
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
 
323
        tree.commit('first', rev_id=b'first-rev-id')
309
324
        tree.remove(['b'])
310
325
 
311
326
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
312
327
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
313
328
        iterator = walker.iter_all()
314
329
        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)
 
330
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
331
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
 
332
        self.assertWalkerNext(u'b', b'b-id', False, [u'b'], iterator)
 
333
        self.assertRaises(StopIteration, next, iterator)
319
334
 
320
335
    def test_other_extra_at_end(self):
321
336
        tree = self.make_branch_and_tree('tree')
322
337
        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')
 
338
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
 
339
        tree.commit('first', rev_id=b'first-rev-id')
325
340
        tree.remove(['d'])
326
341
 
327
342
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
328
343
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
329
344
        iterator = walker.iter_all()
330
345
        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)
 
346
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
 
347
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
 
348
        self.assertWalkerNext(u'd', b'd-id', False, [u'd'], iterator)
 
349
        self.assertRaises(StopIteration, next, iterator)
335
350
 
336
351
    def test_others_extra_at_end(self):
337
352
        tree = self.make_branch_and_tree('tree')
338
353
        self.build_tree(['tree/a', 'tree/b', 'tree/c', 'tree/d', 'tree/e'])
339
354
        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')
 
355
                 [b'a-id', b'b-id', b'c-id', b'd-id', b'e-id'])
 
356
        tree.commit('first', rev_id=b'first-rev-id')
342
357
        tree.remove(['e'])
343
 
        tree.commit('second', rev_id='second-rev-id')
 
358
        tree.commit('second', rev_id=b'second-rev-id')
344
359
        tree.remove(['d'])
345
 
        tree.commit('third', rev_id='third-rev-id')
 
360
        tree.commit('third', rev_id=b'third-rev-id')
346
361
        tree.remove(['c'])
347
362
 
348
363
        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')
 
364
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
 
365
        second_tree = tree.branch.repository.revision_tree(b'second-rev-id')
351
366
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree,
352
367
                                              second_tree])
353
368
        iterator = walker.iter_all()
354
369
        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)
 
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)
 
375
        self.assertRaises(StopIteration, next, iterator)
361
376
 
362
377
    def test_different_file_id_in_others(self):
363
378
        tree = self.make_branch_and_tree('tree')
364
379
        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')
 
380
        tree.add(['a', 'b', 'c'], [b'a-id', b'b-id', b'c-id'])
 
381
        tree.commit('first', rev_id=b'first-rev-id')
367
382
 
368
383
        tree.rename_one('b', 'c/d')
369
384
        self.build_tree(['tree/b'])
370
 
        tree.add(['b'], ['b2-id'])
371
 
        tree.commit('second', rev_id='second-rev-id')
 
385
        tree.add(['b'], [b'b2-id'])
 
386
        tree.commit('second', rev_id=b'second-rev-id')
372
387
 
373
388
        tree.rename_one('a', 'c/e')
374
389
        self.build_tree(['tree/a'])
375
 
        tree.add(['a'], ['a2-id'])
 
390
        tree.add(['a'], [b'a2-id'])
376
391
 
377
392
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
378
 
        first_tree = tree.branch.repository.revision_tree('first-rev-id')
 
393
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
379
394
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree])
380
395
 
381
396
        iterator = walker.iter_all()
382
397
        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):
 
398
        self.assertWalkerNext(u'a', b'a2-id', True, [None, None], iterator)
 
399
        self.assertWalkerNext(u'b', b'b2-id', True, [u'b', None], iterator)
 
400
        self.assertWalkerNext(u'c', b'c-id', True, [u'c', u'c'], iterator)
 
401
        self.assertWalkerNext(u'c/d', b'b-id', True, [u'c/d', u'b'], iterator)
 
402
        self.assertWalkerNext(u'c/e', b'a-id', True, [u'a', u'a'], iterator)
 
403
        self.assertRaises(StopIteration, next, iterator)
 
404
 
 
405
    def assertLtByDirblock(self, lt_val, path1, path2):
 
406
        self.assertEqual(lt_val,
 
407
            _mod_tree.MultiWalker._lt_path_by_dirblock(path1, path2))
 
408
 
 
409
    def test__lt_path_by_dirblock(self):
395
410
        # We only support Unicode strings at this point
396
411
        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')
 
412
            _mod_tree.MultiWalker._lt_path_by_dirblock, b'', b'b')
 
413
        self.assertLtByDirblock(False, u'', u'')
 
414
        self.assertLtByDirblock(False, u'a', u'a')
 
415
        self.assertLtByDirblock(False, u'a/b', u'a/b')
 
416
        self.assertLtByDirblock(False, u'a/b/c', u'a/b/c')
 
417
        self.assertLtByDirblock(False, u'a-a', u'a')
 
418
        self.assertLtByDirblock(True, u'a-a', u'a/a')
 
419
        self.assertLtByDirblock(True, u'a=a', u'a/a')
 
420
        self.assertLtByDirblock(False, u'a-a/a', u'a/a')
 
421
        self.assertLtByDirblock(False, u'a=a/a', u'a/a')
 
422
        self.assertLtByDirblock(False, u'a-a/a', u'a/a/a')
 
423
        self.assertLtByDirblock(False, u'a=a/a', u'a/a/a')
 
424
        self.assertLtByDirblock(False, u'a-a/a/a', u'a/a/a')
 
425
        self.assertLtByDirblock(False, u'a=a/a/a', u'a/a/a')
411
426
 
412
427
    def assertPathToKey(self, expected, path):
413
428
        self.assertEqual(expected, _mod_tree.MultiWalker._path_to_key(path))
417
432
        self.assertPathToKey(([u''], u'a'), u'a')
418
433
        self.assertPathToKey(([u'a'], u'b'), u'a/b')
419
434
        self.assertPathToKey(([u'a', u'b'], u'c'), u'a/b/c')
 
435
 
 
436
 
 
437
class FindPreviousPathsTests(TestCaseWithTransport):
 
438
 
 
439
    def test_new(self):
 
440
        tree = self.make_branch_and_tree('tree')
 
441
        self.build_tree(['tree/b'])
 
442
        tree.add(['b'])
 
443
        revid1 = tree.commit('first')
 
444
        tree1 = tree.branch.repository.revision_tree(revid1)
 
445
 
 
446
        tree0 = tree.branch.repository.revision_tree(revision.NULL_REVISION)
 
447
 
 
448
        self.assertEqual({'b': None}, find_previous_paths(tree1, tree0, ['b']))
 
449
 
 
450
    def test_find_previous_paths(self):
 
451
        tree = self.make_branch_and_tree('tree')
 
452
        self.build_tree(['tree/b'])
 
453
        tree.add(['b'])
 
454
        revid1 = tree.commit('first')
 
455
        tree1 = tree.branch.repository.revision_tree(revid1)
 
456
 
 
457
        tree.rename_one('b', 'c')
 
458
        self.build_tree(['tree/b'])
 
459
        tree.add(['b'])
 
460
        revid2 = tree.commit('second')
 
461
        tree2 = tree.branch.repository.revision_tree(revid2)
 
462
 
 
463
        self.assertEqual({'c': 'b', 'b': None},
 
464
                         find_previous_paths(tree2, tree1, ['b', 'c']))
 
465
 
 
466
 
 
467
class GetCanonicalPath(TestCaseWithTransport):
 
468
 
 
469
    def test_existing_case(self):
 
470
        # Test that we can find a file from a path with different case
 
471
        tree = self.make_branch_and_tree('tree')
 
472
        self.build_tree(['tree/b'])
 
473
        tree.add(['b'])
 
474
        self.assertEqual(
 
475
                'b',
 
476
                get_canonical_path(tree, 'b', lambda x: x.lower()))
 
477
        self.assertEqual(
 
478
                'b',
 
479
                get_canonical_path(tree, 'B', lambda x: x.lower()))
 
480
 
 
481
    def test_nonexistant_preserves_case(self):
 
482
        tree = self.make_branch_and_tree('tree')
 
483
        self.assertEqual(
 
484
                'b',
 
485
                get_canonical_path(tree, 'b', lambda x: x.lower()))
 
486
        self.assertEqual(
 
487
                'B',
 
488
                get_canonical_path(tree, 'B', lambda x: x.lower()))
 
489
 
 
490
    def test_in_directory_with_case(self):
 
491
        tree = self.make_branch_and_tree('tree')
 
492
        self.build_tree(['tree/a/', 'tree/a/b'])
 
493
        tree.add(['a', 'a/b'])
 
494
        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()))