/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 bzrlib/tests/test_tree.py

  • Committer: Robert Collins
  • Date: 2010-05-05 00:05:29 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100505000529-ltmllyms5watqj5u
Make 'pydoc bzrlib.tests.build_tree_shape' useful.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_tree.py
1
 
# Copyright (C) 2006-2009, 2011 Canonical Ltd
 
1
# Copyright (C) 2006, 2008 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 breezy import (
 
19
from bzrlib import (
20
20
    errors,
21
21
    revision,
 
22
    tests,
22
23
    tree as _mod_tree,
23
24
    )
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))
 
25
from bzrlib.tests import TestCaseWithTransport
 
26
from bzrlib.tree import InterTree
42
27
 
43
28
 
44
29
class TestInterTree(TestCaseWithTransport):
83
68
    calls = []
84
69
 
85
70
    def compare(self, want_unchanged=False, specific_files=None,
86
 
                extra_trees=None, require_versioned=False, include_root=False,
87
 
                want_unversioned=False):
 
71
        extra_trees=None, require_versioned=False, include_root=False,
 
72
        want_unversioned=False):
88
73
        self.calls.append(
89
74
            ('compare', self.source, self.target, want_unchanged,
90
75
             specific_files, extra_trees, require_versioned,
115
100
                              'require', True)
116
101
            # pass in all optional arguments by keyword
117
102
            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
 
                              )
 
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
                )
125
110
        finally:
126
111
            InterTree._optimisers = old_optimisers
127
112
        self.assertEqual(
128
113
            [
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),
 
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),
135
119
            ], RecordingOptimiser.calls)
136
120
 
137
121
    def test_changes_from_with_root(self):
149
133
        self.build_tree(['known_file', 'unknown_file'])
150
134
        wt.add('known_file')
151
135
 
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)
 
136
        self.assertRaises(errors.PathsNotVersionedError,
 
137
            wt.changes_from, wt.basis_tree(), wt, specific_files=['known_file',
 
138
            'unknown_file'], require_versioned=True)
157
139
 
158
140
        # we need to pass a known file with an unknown file to get this to
159
141
        # fail when expected.
160
142
        delta = wt.changes_from(wt.basis_tree(),
161
 
                                specific_files=['known_file', 'unknown_file'],
162
 
                                require_versioned=False)
 
143
            specific_files=['known_file', 'unknown_file'] ,
 
144
            require_versioned=False)
163
145
        self.assertEqual(len(delta.added), 1)
164
146
 
165
147
 
187
169
    def test__step_one(self):
188
170
        tree = self.make_branch_and_tree('tree')
189
171
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
190
 
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
 
172
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
191
173
 
192
174
        iterator = tree.iter_entries_by_dir()
193
175
        tree.lock_read()
195
177
 
196
178
        root_id = tree.path2id('')
197
179
        self.assertStepOne(True, '', root_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)
 
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)
201
183
        self.assertStepOne(False, None, None, iterator)
202
184
        self.assertStepOne(False, None, None, iterator)
203
185
 
211
193
        :param exp_other_paths: A list of other_path values.
212
194
        :param iterator: The iterator to step
213
195
        """
214
 
        path, file_id, master_ie, other_values = next(iterator)
 
196
        path, file_id, master_ie, other_values = iterator.next()
215
197
        self.assertEqual((exp_path, exp_file_id), (path, file_id),
216
198
                         'Master entry did not match')
217
199
        if master_has_node:
219
201
        else:
220
202
            self.assertIs(None, master_ie, 'master should not have an entry')
221
203
        self.assertEqual(len(exp_other_paths), len(other_values),
222
 
                         'Wrong number of other entries')
 
204
                            'Wrong number of other entries')
223
205
        other_paths = []
224
206
        other_file_ids = []
225
207
        for path, ie in other_values:
251
233
    def test_simple_stepping(self):
252
234
        tree = self.make_branch_and_tree('tree')
253
235
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
254
 
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
 
236
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
255
237
 
256
 
        tree.commit('first', rev_id=b'first-rev-id')
 
238
        tree.commit('first', rev_id='first-rev-id')
257
239
 
258
240
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
259
241
 
260
242
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
261
243
        iterator = walker.iter_all()
262
244
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
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)
 
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)
267
249
 
268
250
    def test_master_has_extra(self):
269
251
        tree = self.make_branch_and_tree('tree')
270
252
        self.build_tree(['tree/a', 'tree/b/', 'tree/c', 'tree/d'])
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'])
 
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'])
276
258
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
277
259
 
278
260
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
279
261
        iterator = walker.iter_all()
280
262
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
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)
 
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)
286
268
 
287
269
    def test_master_renamed_to_earlier(self):
288
270
        """The record is still present, it just shows up early."""
289
271
        tree = self.make_branch_and_tree('tree')
290
272
        self.build_tree(['tree/a', 'tree/c', 'tree/d'])
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')
 
273
        tree.add(['a', 'c', 'd'], ['a-id', 'c-id', 'd-id'])
 
274
        tree.commit('first', rev_id='first-rev-id')
293
275
        tree.rename_one('d', 'b')
294
276
 
295
277
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
297
279
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
298
280
        iterator = walker.iter_all()
299
281
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
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)
 
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)
304
286
 
305
287
    def test_master_renamed_to_later(self):
306
288
        tree = self.make_branch_and_tree('tree')
307
289
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
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')
 
290
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
291
        tree.commit('first', rev_id='first-rev-id')
310
292
        tree.rename_one('b', 'e')
311
293
 
312
294
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
314
296
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
315
297
        iterator = walker.iter_all()
316
298
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
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)
 
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)
321
303
 
322
304
    def test_other_extra_in_middle(self):
323
305
        tree = self.make_branch_and_tree('tree')
324
306
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
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')
 
307
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
308
        tree.commit('first', rev_id='first-rev-id')
327
309
        tree.remove(['b'])
328
310
 
329
311
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
330
312
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
331
313
        iterator = walker.iter_all()
332
314
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
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)
 
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)
337
319
 
338
320
    def test_other_extra_at_end(self):
339
321
        tree = self.make_branch_and_tree('tree')
340
322
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
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')
 
323
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
324
        tree.commit('first', rev_id='first-rev-id')
343
325
        tree.remove(['d'])
344
326
 
345
327
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
346
328
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
347
329
        iterator = walker.iter_all()
348
330
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
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)
 
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)
353
335
 
354
336
    def test_others_extra_at_end(self):
355
337
        tree = self.make_branch_and_tree('tree')
356
338
        self.build_tree(['tree/a', 'tree/b', 'tree/c', 'tree/d', 'tree/e'])
357
339
        tree.add(['a', 'b', 'c', 'd', 'e'],
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')
 
340
                 ['a-id', 'b-id', 'c-id', 'd-id', 'e-id'])
 
341
        tree.commit('first', rev_id='first-rev-id')
360
342
        tree.remove(['e'])
361
 
        tree.commit('second', rev_id=b'second-rev-id')
 
343
        tree.commit('second', rev_id='second-rev-id')
362
344
        tree.remove(['d'])
363
 
        tree.commit('third', rev_id=b'third-rev-id')
 
345
        tree.commit('third', rev_id='third-rev-id')
364
346
        tree.remove(['c'])
365
347
 
366
348
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
367
 
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
368
 
        second_tree = tree.branch.repository.revision_tree(b'second-rev-id')
 
349
        first_tree = tree.branch.repository.revision_tree('first-rev-id')
 
350
        second_tree = tree.branch.repository.revision_tree('second-rev-id')
369
351
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree,
370
352
                                              second_tree])
371
353
        iterator = walker.iter_all()
372
354
        self.assertWalkerNext(u'', root_id, True, [u'', u'', u''], iterator)
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)
 
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)
384
361
 
385
362
    def test_different_file_id_in_others(self):
386
363
        tree = self.make_branch_and_tree('tree')
387
364
        self.build_tree(['tree/a', 'tree/b', 'tree/c/'])
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')
 
365
        tree.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id'])
 
366
        tree.commit('first', rev_id='first-rev-id')
390
367
 
391
368
        tree.rename_one('b', 'c/d')
392
369
        self.build_tree(['tree/b'])
393
 
        tree.add(['b'], [b'b2-id'])
394
 
        tree.commit('second', rev_id=b'second-rev-id')
 
370
        tree.add(['b'], ['b2-id'])
 
371
        tree.commit('second', rev_id='second-rev-id')
395
372
 
396
373
        tree.rename_one('a', 'c/e')
397
374
        self.build_tree(['tree/a'])
398
 
        tree.add(['a'], [b'a2-id'])
 
375
        tree.add(['a'], ['a2-id'])
399
376
 
400
377
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
401
 
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
 
378
        first_tree = tree.branch.repository.revision_tree('first-rev-id')
402
379
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree])
403
380
 
404
381
        iterator = walker.iter_all()
405
382
        self.assertWalkerNext(u'', root_id, True, [u'', u''], iterator)
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):
 
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):
418
395
        # We only support Unicode strings at this point
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')
 
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')
434
411
 
435
412
    def assertPathToKey(self, expected, path):
436
413
        self.assertEqual(expected, _mod_tree.MultiWalker._path_to_key(path))
440
417
        self.assertPathToKey(([u''], u'a'), u'a')
441
418
        self.assertPathToKey(([u'a'], u'b'), u'a/b')
442
419
        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()))