← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

  • Committer: Aaron Bentley
  • Date: 2009-04-14 15:02:46 UTC
  • mto: This revision was merged to the branch mainline in revision 4302.
  • Revision ID: aaron@aaronbentley.com-20090414150246-6xfd3bwwf2m8v4px
Cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
 
18
import os.path
18
19
from cStringIO import StringIO
 
20
import errno
19
21
import subprocess
20
22
import sys
21
 
import tempfile
 
23
from tempfile import TemporaryFile
22
24
 
23
 
from bzrlib import (
24
 
    diff,
25
 
    errors,
26
 
    osutils,
27
 
    patiencediff,
28
 
    _patiencediff_py,
29
 
    revision as _mod_revision,
30
 
    revisionspec,
31
 
    revisiontree,
32
 
    tests,
33
 
    transform,
 
25
from bzrlib import tests
 
26
from bzrlib.diff import (
 
27
    DiffFromTool,
 
28
    DiffPath,
 
29
    DiffSymlink,
 
30
    DiffTree,
 
31
    DiffText,
 
32
    external_diff,
 
33
    internal_diff,
 
34
    show_diff_trees,
34
35
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features, EncodingAdapter
37
 
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
 
39
 
 
40
 
class _AttribFeature(tests.Feature):
 
36
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
 
37
import bzrlib.osutils as osutils
 
38
import bzrlib.revision as _mod_revision
 
39
import bzrlib.transform as transform
 
40
import bzrlib.patiencediff
 
41
import bzrlib._patiencediff_py
 
42
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
43
                          TestCaseInTempDir, TestSkipped)
 
44
 
 
45
 
 
46
class _AttribFeature(Feature):
41
47
 
42
48
    def _probe(self):
43
49
        if (sys.platform not in ('cygwin', 'win32')):
54
60
AttribFeature = _AttribFeature()
55
61
 
56
62
 
57
 
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
58
 
                                    'bzrlib._patiencediff_c')
 
63
class _CompiledPatienceDiffFeature(Feature):
 
64
 
 
65
    def _probe(self):
 
66
        try:
 
67
            import bzrlib._patiencediff_c
 
68
        except ImportError:
 
69
            return False
 
70
        return True
 
71
 
 
72
    def feature_name(self):
 
73
        return 'bzrlib._patiencediff_c'
 
74
 
 
75
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
59
76
 
60
77
 
61
78
def udiff_lines(old, new, allow_binary=False):
62
79
    output = StringIO()
63
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
80
    internal_diff('old', old, 'new', new, output, allow_binary)
64
81
    output.seek(0, 0)
65
82
    return output.readlines()
66
83
 
70
87
        # StringIO has no fileno, so it tests a different codepath
71
88
        output = StringIO()
72
89
    else:
73
 
        output = tempfile.TemporaryFile()
 
90
        output = TemporaryFile()
74
91
    try:
75
 
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
76
 
    except errors.NoDiff:
77
 
        raise tests.TestSkipped('external "diff" not present to test')
 
92
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
93
    except NoDiff:
 
94
        raise TestSkipped('external "diff" not present to test')
78
95
    output.seek(0, 0)
79
96
    lines = output.readlines()
80
97
    output.close()
81
98
    return lines
82
99
 
83
100
 
84
 
class TestDiff(tests.TestCase):
 
101
class TestDiff(TestCase):
85
102
 
86
103
    def test_add_nl(self):
87
104
        """diff generates a valid diff for patches that add a newline"""
123
140
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
124
141
 
125
142
    def test_binary_lines(self):
126
 
        empty = []
127
 
        uni_lines = [1023 * 'a' + '\x00']
128
 
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
129
 
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
130
 
        udiff_lines(uni_lines , empty, allow_binary=True)
131
 
        udiff_lines(empty, uni_lines, allow_binary=True)
 
143
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
144
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
145
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
146
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
132
147
 
133
148
    def test_external_diff(self):
134
149
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
144
159
        self.check_patch(lines)
145
160
 
146
161
    def test_external_diff_binary_lang_c(self):
 
162
        old_env = {}
147
163
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
148
 
            self.overrideEnv(lang, 'C')
149
 
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
150
 
        # Older versions of diffutils say "Binary files", newer
151
 
        # versions just say "Files".
152
 
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
153
 
        self.assertEquals(lines[1:], ['\n'])
 
164
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
165
        try:
 
166
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
167
            # Older versions of diffutils say "Binary files", newer
 
168
            # versions just say "Files".
 
169
            self.assertContainsRe(lines[0],
 
170
                                  '(Binary f|F)iles old and new differ\n')
 
171
            self.assertEquals(lines[1:], ['\n'])
 
172
        finally:
 
173
            for lang, old_val in old_env.iteritems():
 
174
                osutils.set_or_unset_env(lang, old_val)
154
175
 
155
176
    def test_no_external_diff(self):
156
177
        """Check that NoDiff is raised when diff is not available"""
157
 
        # Make sure no 'diff' command is available
158
 
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
159
 
        self.overrideEnv('PATH', '')
160
 
        self.assertRaises(errors.NoDiff, diff.external_diff,
161
 
                          'old', ['boo\n'], 'new', ['goo\n'],
162
 
                          StringIO(), diff_opts=['-u'])
 
178
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
179
        orig_path = os.environ['PATH']
 
180
        try:
 
181
            os.environ['PATH'] = ''
 
182
            self.assertRaises(NoDiff, external_diff,
 
183
                              'old', ['boo\n'], 'new', ['goo\n'],
 
184
                              StringIO(), diff_opts=['-u'])
 
185
        finally:
 
186
            os.environ['PATH'] = orig_path
163
187
 
164
188
    def test_internal_diff_default(self):
165
189
        # Default internal diff encoding is utf8
166
190
        output = StringIO()
167
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
168
 
                           u'new_\xe5', ['new_text\n'], output)
 
191
        internal_diff(u'old_\xb5', ['old_text\n'],
 
192
                    u'new_\xe5', ['new_text\n'], output)
169
193
        lines = output.getvalue().splitlines(True)
170
194
        self.check_patch(lines)
171
195
        self.assertEquals(['--- old_\xc2\xb5\n',
179
203
 
180
204
    def test_internal_diff_utf8(self):
181
205
        output = StringIO()
182
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
183
 
                           u'new_\xe5', ['new_text\n'], output,
184
 
                           path_encoding='utf8')
 
206
        internal_diff(u'old_\xb5', ['old_text\n'],
 
207
                    u'new_\xe5', ['new_text\n'], output,
 
208
                    path_encoding='utf8')
185
209
        lines = output.getvalue().splitlines(True)
186
210
        self.check_patch(lines)
187
211
        self.assertEquals(['--- old_\xc2\xb5\n',
195
219
 
196
220
    def test_internal_diff_iso_8859_1(self):
197
221
        output = StringIO()
198
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
199
 
                           u'new_\xe5', ['new_text\n'], output,
200
 
                           path_encoding='iso-8859-1')
 
222
        internal_diff(u'old_\xb5', ['old_text\n'],
 
223
                    u'new_\xe5', ['new_text\n'], output,
 
224
                    path_encoding='iso-8859-1')
201
225
        lines = output.getvalue().splitlines(True)
202
226
        self.check_patch(lines)
203
227
        self.assertEquals(['--- old_\xb5\n',
211
235
 
212
236
    def test_internal_diff_no_content(self):
213
237
        output = StringIO()
214
 
        diff.internal_diff(u'old', [], u'new', [], output)
 
238
        internal_diff(u'old', [], u'new', [], output)
215
239
        self.assertEqual('', output.getvalue())
216
240
 
217
241
    def test_internal_diff_no_changes(self):
218
242
        output = StringIO()
219
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
220
 
                           u'new', ['text\n', 'contents\n'],
221
 
                           output)
 
243
        internal_diff(u'old', ['text\n', 'contents\n'],
 
244
                      u'new', ['text\n', 'contents\n'],
 
245
                      output)
222
246
        self.assertEqual('', output.getvalue())
223
247
 
224
248
    def test_internal_diff_returns_bytes(self):
225
249
        import StringIO
226
250
        output = StringIO.StringIO()
227
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
228
 
                            u'new_\xe5', ['new_text\n'], output)
229
 
        self.assertIsInstance(output.getvalue(), str,
 
251
        internal_diff(u'old_\xb5', ['old_text\n'],
 
252
                    u'new_\xe5', ['new_text\n'], output)
 
253
        self.failUnless(isinstance(output.getvalue(), str),
230
254
            'internal_diff should return bytestrings')
231
255
 
232
256
 
233
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
257
class TestDiffFiles(TestCaseInTempDir):
234
258
 
235
259
    def test_external_diff_binary(self):
236
260
        """The output when using external diff should use diff's i18n error"""
249
273
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
250
274
 
251
275
 
252
 
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
253
 
    output = StringIO()
254
 
    if working_tree is not None:
255
 
        extra_trees = (working_tree,)
256
 
    else:
257
 
        extra_trees = ()
258
 
    diff.show_diff_trees(tree1, tree2, output,
259
 
        specific_files=specific_files,
260
 
        extra_trees=extra_trees, old_label='old/',
261
 
        new_label='new/')
262
 
    return output.getvalue()
263
 
 
264
 
 
265
 
class TestDiffDates(tests.TestCaseWithTransport):
 
276
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
277
    """Has a helper for running show_diff_trees"""
 
278
 
 
279
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
280
        output = StringIO()
 
281
        if working_tree is not None:
 
282
            extra_trees = (working_tree,)
 
283
        else:
 
284
            extra_trees = ()
 
285
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
286
                        extra_trees=extra_trees, old_label='old/',
 
287
                        new_label='new/')
 
288
        return output.getvalue()
 
289
 
 
290
 
 
291
class TestDiffDates(TestShowDiffTreesHelper):
266
292
 
267
293
    def setUp(self):
268
294
        super(TestDiffDates, self).setUp()
303
329
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
304
330
 
305
331
    def test_diff_rev_tree_working_tree(self):
306
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
332
        output = self.get_diff(self.wt.basis_tree(), self.wt)
307
333
        # note that the date for old/file1 is from rev 2 rather than from
308
334
        # the basis revision (rev 4)
309
335
        self.assertEqualDiff(output, '''\
319
345
    def test_diff_rev_tree_rev_tree(self):
320
346
        tree1 = self.b.repository.revision_tree('rev-2')
321
347
        tree2 = self.b.repository.revision_tree('rev-3')
322
 
        output = get_diff_as_string(tree1, tree2)
 
348
        output = self.get_diff(tree1, tree2)
323
349
        self.assertEqualDiff(output, '''\
324
350
=== modified file 'file2'
325
351
--- old/file2\t2006-04-01 00:00:00 +0000
333
359
    def test_diff_add_files(self):
334
360
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
335
361
        tree2 = self.b.repository.revision_tree('rev-1')
336
 
        output = get_diff_as_string(tree1, tree2)
 
362
        output = self.get_diff(tree1, tree2)
337
363
        # the files have the epoch time stamp for the tree in which
338
364
        # they don't exist.
339
365
        self.assertEqualDiff(output, '''\
354
380
    def test_diff_remove_files(self):
355
381
        tree1 = self.b.repository.revision_tree('rev-3')
356
382
        tree2 = self.b.repository.revision_tree('rev-4')
357
 
        output = get_diff_as_string(tree1, tree2)
 
383
        output = self.get_diff(tree1, tree2)
358
384
        # the file has the epoch time stamp for the tree in which
359
385
        # it doesn't exist.
360
386
        self.assertEqualDiff(output, '''\
371
397
        self.wt.rename_one('file1', 'file1b')
372
398
        old_tree = self.b.repository.revision_tree('rev-1')
373
399
        new_tree = self.b.repository.revision_tree('rev-4')
374
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
 
400
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
375
401
                            working_tree=self.wt)
376
402
        self.assertContainsRe(out, 'file1\t')
377
403
 
383
409
        self.wt.rename_one('file1', 'dir1/file1')
384
410
        old_tree = self.b.repository.revision_tree('rev-1')
385
411
        new_tree = self.b.repository.revision_tree('rev-4')
386
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
 
412
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
387
413
                            working_tree=self.wt)
388
414
        self.assertContainsRe(out, 'file1\t')
389
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
 
415
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
390
416
                            working_tree=self.wt)
391
417
        self.assertNotContainsRe(out, 'file1\t')
392
418
 
393
419
 
394
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
420
 
 
421
class TestShowDiffTrees(TestShowDiffTreesHelper):
395
422
    """Direct tests for show_diff_trees"""
396
423
 
397
424
    def test_modified_file(self):
402
429
        tree.commit('one', rev_id='rev-1')
403
430
 
404
431
        self.build_tree_contents([('tree/file', 'new contents\n')])
405
 
        d = get_diff_as_string(tree.basis_tree(), tree)
406
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
407
 
        self.assertContainsRe(d, '--- old/file\t')
408
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
409
 
        self.assertContainsRe(d, '-contents\n'
410
 
                                 '\\+new contents\n')
 
432
        diff = self.get_diff(tree.basis_tree(), tree)
 
433
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
434
        self.assertContainsRe(diff, '--- old/file\t')
 
435
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
436
        self.assertContainsRe(diff, '-contents\n'
 
437
                                    '\\+new contents\n')
411
438
 
412
439
    def test_modified_file_in_renamed_dir(self):
413
440
        """Test when a file is modified in a renamed directory."""
419
446
 
420
447
        tree.rename_one('dir', 'other')
421
448
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
422
 
        d = get_diff_as_string(tree.basis_tree(), tree)
423
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
424
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
449
        diff = self.get_diff(tree.basis_tree(), tree)
 
450
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
451
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
425
452
        # XXX: This is technically incorrect, because it used to be at another
426
453
        # location. What to do?
427
 
        self.assertContainsRe(d, '--- old/dir/file\t')
428
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
429
 
        self.assertContainsRe(d, '-contents\n'
430
 
                                 '\\+new contents\n')
 
454
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
455
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
456
        self.assertContainsRe(diff, '-contents\n'
 
457
                                    '\\+new contents\n')
431
458
 
432
459
    def test_renamed_directory(self):
433
460
        """Test when only a directory is only renamed."""
438
465
        tree.commit('one', rev_id='rev-1')
439
466
 
440
467
        tree.rename_one('dir', 'newdir')
441
 
        d = get_diff_as_string(tree.basis_tree(), tree)
 
468
        diff = self.get_diff(tree.basis_tree(), tree)
442
469
        # Renaming a directory should be a single "you renamed this dir" even
443
470
        # when there are files inside.
444
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
471
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
445
472
 
446
473
    def test_renamed_file(self):
447
474
        """Test when a file is only renamed."""
451
478
        tree.commit('one', rev_id='rev-1')
452
479
 
453
480
        tree.rename_one('file', 'newname')
454
 
        d = get_diff_as_string(tree.basis_tree(), tree)
455
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
481
        diff = self.get_diff(tree.basis_tree(), tree)
 
482
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
456
483
        # We shouldn't have a --- or +++ line, because there is no content
457
484
        # change
458
 
        self.assertNotContainsRe(d, '---')
 
485
        self.assertNotContainsRe(diff, '---')
459
486
 
460
487
    def test_renamed_and_modified_file(self):
461
488
        """Test when a file is only renamed."""
466
493
 
467
494
        tree.rename_one('file', 'newname')
468
495
        self.build_tree_contents([('tree/newname', 'new contents\n')])
469
 
        d = get_diff_as_string(tree.basis_tree(), tree)
470
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
471
 
        self.assertContainsRe(d, '--- old/file\t')
472
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
473
 
        self.assertContainsRe(d, '-contents\n'
474
 
                                 '\\+new contents\n')
 
496
        diff = self.get_diff(tree.basis_tree(), tree)
 
497
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
498
        self.assertContainsRe(diff, '--- old/file\t')
 
499
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
500
        self.assertContainsRe(diff, '-contents\n'
 
501
                                    '\\+new contents\n')
475
502
 
476
503
 
477
504
    def test_internal_diff_exec_property(self):
496
523
        tree.rename_one('c', 'new-c')
497
524
        tree.rename_one('d', 'new-d')
498
525
 
499
 
        d = get_diff_as_string(tree.basis_tree(), tree)
500
 
 
501
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
502
 
                                  ".*\+x to -x.*\)")
503
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
504
 
                                  ".*-x to \+x.*\)")
505
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
506
 
                                  ".*\+x to -x.*\)")
507
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
508
 
                                  ".*-x to \+x.*\)")
509
 
        self.assertNotContainsRe(d, r"file 'e'")
510
 
        self.assertNotContainsRe(d, r"file 'f'")
 
526
        diff = self.get_diff(tree.basis_tree(), tree)
 
527
 
 
528
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
529
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
530
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
531
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
532
        self.assertNotContainsRe(diff, r"file 'e'")
 
533
        self.assertNotContainsRe(diff, r"file 'f'")
 
534
 
511
535
 
512
536
    def test_binary_unicode_filenames(self):
513
537
        """Test that contents of files are *not* encoded in UTF-8 when there
528
552
        tree.add([alpha], ['file-id'])
529
553
        tree.add([omega], ['file-id-2'])
530
554
        diff_content = StringIO()
531
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
532
 
        d = diff_content.getvalue()
533
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
534
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
535
 
                              % (alpha_utf8, alpha_utf8))
536
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
537
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
538
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
555
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
556
        diff = diff_content.getvalue()
 
557
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
558
        self.assertContainsRe(
 
559
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
560
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
561
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
562
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
539
563
 
540
564
    def test_unicode_filename(self):
541
565
        """Test when the filename are unicode."""
560
584
        tree.add(['add_'+alpha], ['file-id'])
561
585
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
562
586
 
563
 
        d = get_diff_as_string(tree.basis_tree(), tree)
564
 
        self.assertContainsRe(d,
 
587
        diff = self.get_diff(tree.basis_tree(), tree)
 
588
        self.assertContainsRe(diff,
565
589
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
566
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
567
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
568
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
569
 
 
570
 
    def test_unicode_filename_path_encoding(self):
571
 
        """Test for bug #382699: unicode filenames on Windows should be shown
572
 
        in user encoding.
573
 
        """
574
 
        self.requireFeature(tests.UnicodeFilenameFeature)
575
 
        # The word 'test' in Russian
576
 
        _russian_test = u'\u0422\u0435\u0441\u0442'
577
 
        directory = _russian_test + u'/'
578
 
        test_txt = _russian_test + u'.txt'
579
 
        u1234 = u'\u1234.txt'
580
 
 
581
 
        tree = self.make_branch_and_tree('.')
582
 
        self.build_tree_contents([
583
 
            (test_txt, 'foo\n'),
584
 
            (u1234, 'foo\n'),
585
 
            (directory, None),
586
 
            ])
587
 
        tree.add([test_txt, u1234, directory])
588
 
 
589
 
        sio = StringIO()
590
 
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
591
 
            path_encoding='cp1251')
592
 
 
593
 
        output = subst_dates(sio.getvalue())
594
 
        shouldbe = ('''\
595
 
=== added directory '%(directory)s'
596
 
=== added file '%(test_txt)s'
597
 
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
598
 
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
599
 
@@ -0,0 +1,1 @@
600
 
+foo
601
 
 
602
 
=== added file '?.txt'
603
 
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
604
 
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
605
 
@@ -0,0 +1,1 @@
606
 
+foo
607
 
 
608
 
''' % {'directory': _russian_test.encode('cp1251'),
609
 
       'test_txt': test_txt.encode('cp1251'),
610
 
      })
611
 
        self.assertEqualDiff(output, shouldbe)
612
 
 
613
 
 
614
 
class DiffWasIs(diff.DiffPath):
 
590
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
591
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
592
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
593
 
 
594
 
 
595
class DiffWasIs(DiffPath):
615
596
 
616
597
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
617
598
        self.to_file.write('was: ')
621
602
        pass
622
603
 
623
604
 
624
 
class TestDiffTree(tests.TestCaseWithTransport):
 
605
class TestDiffTree(TestCaseWithTransport):
625
606
 
626
607
    def setUp(self):
627
 
        super(TestDiffTree, self).setUp()
 
608
        TestCaseWithTransport.setUp(self)
628
609
        self.old_tree = self.make_branch_and_tree('old-tree')
629
610
        self.old_tree.lock_write()
630
611
        self.addCleanup(self.old_tree.unlock)
631
612
        self.new_tree = self.make_branch_and_tree('new-tree')
632
613
        self.new_tree.lock_write()
633
614
        self.addCleanup(self.new_tree.unlock)
634
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
615
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
635
616
 
636
617
    def test_diff_text(self):
637
618
        self.build_tree_contents([('old-tree/olddir/',),
642
623
                                  ('new-tree/newdir/newfile', 'new\n')])
643
624
        self.new_tree.add('newdir')
644
625
        self.new_tree.add('newdir/newfile', 'file-id')
645
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
626
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
646
627
        differ.diff_text('file-id', None, 'old label', 'new label')
647
628
        self.assertEqual(
648
629
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
677
658
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
678
659
 
679
660
    def test_diff_symlink(self):
680
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
661
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
681
662
        differ.diff_symlink('old target', None)
682
663
        self.assertEqual("=== target was 'old target'\n",
683
664
                         differ.to_file.getvalue())
684
665
 
685
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
666
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
686
667
        differ.diff_symlink(None, 'new target')
687
668
        self.assertEqual("=== target is 'new target'\n",
688
669
                         differ.to_file.getvalue())
689
670
 
690
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
671
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
691
672
        differ.diff_symlink('old target', 'new target')
692
673
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
693
674
                         differ.to_file.getvalue())
743
724
 
744
725
    def test_register_diff(self):
745
726
        self.create_old_new()
746
 
        old_diff_factories = diff.DiffTree.diff_factories
747
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
748
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
727
        old_diff_factories = DiffTree.diff_factories
 
728
        DiffTree.diff_factories=old_diff_factories[:]
 
729
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
749
730
        try:
750
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
731
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
751
732
        finally:
752
 
            diff.DiffTree.diff_factories = old_diff_factories
 
733
            DiffTree.diff_factories = old_diff_factories
753
734
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
754
735
        self.assertNotContainsRe(
755
736
            differ.to_file.getvalue(),
760
741
 
761
742
    def test_extra_factories(self):
762
743
        self.create_old_new()
763
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
764
 
                               extra_factories=[DiffWasIs.from_diff_tree])
 
744
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
745
                            extra_factories=[DiffWasIs.from_diff_tree])
765
746
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
766
747
        self.assertNotContainsRe(
767
748
            differ.to_file.getvalue(),
780
761
            '.*a-file(.|\n)*b-file')
781
762
 
782
763
 
783
 
class TestPatienceDiffLib(tests.TestCase):
 
764
class TestPatienceDiffLib(TestCase):
784
765
 
785
766
    def setUp(self):
786
767
        super(TestPatienceDiffLib, self).setUp()
787
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
788
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
768
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
769
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
789
770
        self._PatienceSequenceMatcher = \
790
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
771
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
791
772
 
792
773
    def test_diff_unicode_string(self):
793
774
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
1100
1081
                 'how are you today?\n']
1101
1082
        txt_b = ['hello there\n',
1102
1083
                 'how are you today?\n']
1103
 
        unified_diff = patiencediff.unified_diff
 
1084
        unified_diff = bzrlib.patiencediff.unified_diff
1104
1085
        psm = self._PatienceSequenceMatcher
1105
1086
        self.assertEquals(['--- \n',
1106
1087
                           '+++ \n',
1154
1135
                 'how are you today?\n']
1155
1136
        txt_b = ['hello there\n',
1156
1137
                 'how are you today?\n']
1157
 
        unified_diff = patiencediff.unified_diff
 
1138
        unified_diff = bzrlib.patiencediff.unified_diff
1158
1139
        psm = self._PatienceSequenceMatcher
1159
1140
        self.assertEquals(['--- a\t2008-08-08\n',
1160
1141
                           '+++ b\t2008-09-09\n',
1172
1153
 
1173
1154
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1174
1155
 
1175
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1156
    _test_needs_features = [CompiledPatienceDiffFeature]
1176
1157
 
1177
1158
    def setUp(self):
1178
1159
        super(TestPatienceDiffLib_c, self).setUp()
1179
 
        from bzrlib import _patiencediff_c
1180
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1181
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1160
        import bzrlib._patiencediff_c
 
1161
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1162
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1182
1163
        self._PatienceSequenceMatcher = \
1183
 
            _patiencediff_c.PatienceSequenceMatcher_c
 
1164
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1184
1165
 
1185
1166
    def test_unhashable(self):
1186
1167
        """We should get a proper exception here."""
1196
1177
                                         None, ['valid'], ['valid', []])
1197
1178
 
1198
1179
 
1199
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1180
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1200
1181
 
1201
1182
    def setUp(self):
1202
1183
        super(TestPatienceDiffLibFiles, self).setUp()
1203
1184
        self._PatienceSequenceMatcher = \
1204
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
1185
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1205
1186
 
1206
1187
    def test_patience_unified_diff_files(self):
1207
1188
        txt_a = ['hello there\n',
1212
1193
        open('a1', 'wb').writelines(txt_a)
1213
1194
        open('b1', 'wb').writelines(txt_b)
1214
1195
 
1215
 
        unified_diff_files = patiencediff.unified_diff_files
 
1196
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1216
1197
        psm = self._PatienceSequenceMatcher
1217
1198
        self.assertEquals(['--- a1\n',
1218
1199
                           '+++ b1\n',
1268
1249
 
1269
1250
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1270
1251
 
1271
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1252
    _test_needs_features = [CompiledPatienceDiffFeature]
1272
1253
 
1273
1254
    def setUp(self):
1274
1255
        super(TestPatienceDiffLibFiles_c, self).setUp()
1275
 
        from bzrlib import _patiencediff_c
 
1256
        import bzrlib._patiencediff_c
1276
1257
        self._PatienceSequenceMatcher = \
1277
 
            _patiencediff_c.PatienceSequenceMatcher_c
1278
 
 
1279
 
 
1280
 
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1258
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1259
 
 
1260
 
 
1261
class TestUsingCompiledIfAvailable(TestCase):
1281
1262
 
1282
1263
    def test_PatienceSequenceMatcher(self):
1283
 
        if compiled_patiencediff_feature.available():
 
1264
        if CompiledPatienceDiffFeature.available():
1284
1265
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1285
1266
            self.assertIs(PatienceSequenceMatcher_c,
1286
 
                          patiencediff.PatienceSequenceMatcher)
 
1267
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1287
1268
        else:
1288
1269
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1289
1270
            self.assertIs(PatienceSequenceMatcher_py,
1290
 
                          patiencediff.PatienceSequenceMatcher)
 
1271
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1291
1272
 
1292
1273
    def test_unique_lcs(self):
1293
 
        if compiled_patiencediff_feature.available():
 
1274
        if CompiledPatienceDiffFeature.available():
1294
1275
            from bzrlib._patiencediff_c import unique_lcs_c
1295
1276
            self.assertIs(unique_lcs_c,
1296
 
                          patiencediff.unique_lcs)
 
1277
                          bzrlib.patiencediff.unique_lcs)
1297
1278
        else:
1298
1279
            from bzrlib._patiencediff_py import unique_lcs_py
1299
1280
            self.assertIs(unique_lcs_py,
1300
 
                          patiencediff.unique_lcs)
 
1281
                          bzrlib.patiencediff.unique_lcs)
1301
1282
 
1302
1283
    def test_recurse_matches(self):
1303
 
        if compiled_patiencediff_feature.available():
 
1284
        if CompiledPatienceDiffFeature.available():
1304
1285
            from bzrlib._patiencediff_c import recurse_matches_c
1305
1286
            self.assertIs(recurse_matches_c,
1306
 
                          patiencediff.recurse_matches)
 
1287
                          bzrlib.patiencediff.recurse_matches)
1307
1288
        else:
1308
1289
            from bzrlib._patiencediff_py import recurse_matches_py
1309
1290
            self.assertIs(recurse_matches_py,
1310
 
                          patiencediff.recurse_matches)
1311
 
 
1312
 
 
1313
 
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1291
                          bzrlib.patiencediff.recurse_matches)
 
1292
 
 
1293
 
 
1294
class TestDiffFromTool(TestCaseWithTransport):
1314
1295
 
1315
1296
    def test_from_string(self):
1316
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1297
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1317
1298
        self.addCleanup(diff_obj.finish)
1318
 
        self.assertEqual(['diff', '@old_path', '@new_path'],
 
1299
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
1319
1300
            diff_obj.command_template)
1320
1301
 
1321
1302
    def test_from_string_u5(self):
1322
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1323
 
                                                 None, None, None)
 
1303
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
1324
1304
        self.addCleanup(diff_obj.finish)
1325
 
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
 
1305
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
1326
1306
                         diff_obj.command_template)
1327
1307
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1328
1308
                         diff_obj._get_command('old-path', 'new-path'))
1329
1309
 
1330
 
    def test_from_string_path_with_backslashes(self):
1331
 
        self.requireFeature(features.backslashdir_feature)
1332
 
        tool = 'C:\\Tools\\Diff.exe'
1333
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1334
 
        self.addCleanup(diff_obj.finish)
1335
 
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1336
 
                         diff_obj.command_template)
1337
 
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1338
 
                         diff_obj._get_command('old-path', 'new-path'))
1339
 
 
1340
1310
    def test_execute(self):
1341
1311
        output = StringIO()
1342
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1343
 
                                      'print "@old_path @new_path"'],
1344
 
                                     None, None, output)
 
1312
        diff_obj = DiffFromTool(['python', '-c',
 
1313
                                 'print "%(old_path)s %(new_path)s"'],
 
1314
                                None, None, output)
1345
1315
        self.addCleanup(diff_obj.finish)
1346
1316
        diff_obj._execute('old', 'new')
1347
1317
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1348
1318
 
1349
1319
    def test_excute_missing(self):
1350
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1351
 
                                     None, None, None)
 
1320
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1321
                                None, None, None)
1352
1322
        self.addCleanup(diff_obj.finish)
1353
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1354
 
                              'old', 'new')
 
1323
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1324
                              'new')
1355
1325
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1356
1326
                         ' on this machine', str(e))
1357
1327
 
1364
1334
        tree.commit('old tree')
1365
1335
        tree.lock_read()
1366
1336
        self.addCleanup(tree.unlock)
1367
 
        basis_tree = tree.basis_tree()
1368
 
        basis_tree.lock_read()
1369
 
        self.addCleanup(basis_tree.unlock)
1370
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1371
 
                                      'print "@old_path @new_path"'],
1372
 
                                     basis_tree, tree, output)
 
1337
        diff_obj = DiffFromTool(['python', '-c',
 
1338
                                 'print "%(old_path)s %(new_path)s"'],
 
1339
                                tree, tree, output)
1373
1340
        diff_obj._prepare_files('file-id', 'file', 'file')
1374
 
        # The old content should be readonly
1375
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1376
 
                                    r'R.*old\\file$')
1377
 
        # The new content should use the tree object, not a 'new' file anymore
1378
 
        self.assertEndsWith(tree.basedir, 'work/tree')
1379
 
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
 
1341
        self.assertReadableByAttrib(diff_obj._root, 'old\\file', r'old\\file')
 
1342
        self.assertReadableByAttrib(diff_obj._root, 'new\\file', r'new\\file')
1380
1343
 
1381
1344
    def assertReadableByAttrib(self, cwd, relpath, regex):
1382
1345
        proc = subprocess.Popen(['attrib', relpath],
1383
1346
                                stdout=subprocess.PIPE,
1384
1347
                                cwd=cwd)
1385
 
        (result, err) = proc.communicate()
1386
 
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
 
1348
        proc.wait()
 
1349
        result = proc.stdout.read()
 
1350
        self.assertContainsRe(result, regex)
1387
1351
 
1388
1352
    def test_prepare_files(self):
1389
1353
        output = StringIO()
1392
1356
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1393
1357
        tree.add('oldname', 'file-id')
1394
1358
        tree.add('oldname2', 'file2-id')
1395
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1396
 
        tree.commit('old tree', timestamp=315532800)
 
1359
        tree.commit('old tree', timestamp=0)
1397
1360
        tree.rename_one('oldname', 'newname')
1398
1361
        tree.rename_one('oldname2', 'newname2')
1399
1362
        self.build_tree_contents([('tree/newname', 'newcontent')])
1403
1366
        self.addCleanup(old_tree.unlock)
1404
1367
        tree.lock_read()
1405
1368
        self.addCleanup(tree.unlock)
1406
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1407
 
                                      'print "@old_path @new_path"'],
1408
 
                                     old_tree, tree, output)
 
1369
        diff_obj = DiffFromTool(['python', '-c',
 
1370
                                 'print "%(old_path)s %(new_path)s"'],
 
1371
                                old_tree, tree, output)
1409
1372
        self.addCleanup(diff_obj.finish)
1410
1373
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1411
1374
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1412
1375
                                                     'newname')
1413
1376
        self.assertContainsRe(old_path, 'old/oldname$')
1414
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
1415
 
        self.assertContainsRe(new_path, 'tree/newname$')
 
1377
        self.assertEqual(0, os.stat(old_path).st_mtime)
 
1378
        self.assertContainsRe(new_path, 'new/newname$')
1416
1379
        self.assertFileEqual('oldcontent', old_path)
1417
1380
        self.assertFileEqual('newcontent', new_path)
1418
1381
        if osutils.host_os_dereferences_symlinks():
1419
1382
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1420
1383
        # make sure we can create files with the same parent directories
1421
1384
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1422
 
 
1423
 
 
1424
 
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
1425
 
 
1426
 
    def test_encodable_filename(self):
1427
 
        # Just checks file path for external diff tool.
1428
 
        # We cannot change CPython's internal encoding used by os.exec*.
1429
 
        import sys
1430
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1431
 
                                    None, None, None)
1432
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1433
 
            encoding = scenario['encoding']
1434
 
            dirname  = scenario['info']['directory']
1435
 
            filename = scenario['info']['filename']
1436
 
 
1437
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1438
 
            relpath = dirname + u'/' + filename
1439
 
            fullpath = diffobj._safe_filename('safe', relpath)
1440
 
            self.assertEqual(
1441
 
                    fullpath,
1442
 
                    fullpath.encode(encoding).decode(encoding)
1443
 
                    )
1444
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1445
 
 
1446
 
    def test_unencodable_filename(self):
1447
 
        import sys
1448
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1449
 
                                    None, None, None)
1450
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1451
 
            encoding = scenario['encoding']
1452
 
            dirname  = scenario['info']['directory']
1453
 
            filename = scenario['info']['filename']
1454
 
 
1455
 
            if encoding == 'iso-8859-1':
1456
 
                encoding = 'iso-8859-2'
1457
 
            else:
1458
 
                encoding = 'iso-8859-1'
1459
 
 
1460
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1461
 
            relpath = dirname + u'/' + filename
1462
 
            fullpath = diffobj._safe_filename('safe', relpath)
1463
 
            self.assertEqual(
1464
 
                    fullpath,
1465
 
                    fullpath.encode(encoding).decode(encoding)
1466
 
                    )
1467
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1468
 
 
1469
 
 
1470
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1471
 
 
1472
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1473
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1474
 
        TestGetTreesAndBranchesToDiff.
1475
 
        """
1476
 
        return diff.get_trees_and_branches_to_diff_locked(
1477
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1478
 
 
1479
 
    def test_basic(self):
1480
 
        tree = self.make_branch_and_tree('tree')
1481
 
        (old_tree, new_tree,
1482
 
         old_branch, new_branch,
1483
 
         specific_files, extra_trees) = self.call_gtabtd(
1484
 
             ['tree'], None, None, None)
1485
 
 
1486
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1487
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1488
 
                         old_tree.get_revision_id())
1489
 
        self.assertEqual(tree.basedir, new_tree.basedir)
1490
 
        self.assertEqual(tree.branch.base, old_branch.base)
1491
 
        self.assertEqual(tree.branch.base, new_branch.base)
1492
 
        self.assertIs(None, specific_files)
1493
 
        self.assertIs(None, extra_trees)
1494
 
 
1495
 
    def test_with_rev_specs(self):
1496
 
        tree = self.make_branch_and_tree('tree')
1497
 
        self.build_tree_contents([('tree/file', 'oldcontent')])
1498
 
        tree.add('file', 'file-id')
1499
 
        tree.commit('old tree', timestamp=0, rev_id="old-id")
1500
 
        self.build_tree_contents([('tree/file', 'newcontent')])
1501
 
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1502
 
 
1503
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1504
 
                     revisionspec.RevisionSpec.from_string('2')]
1505
 
        (old_tree, new_tree,
1506
 
         old_branch, new_branch,
1507
 
         specific_files, extra_trees) = self.call_gtabtd(
1508
 
            ['tree'], revisions, None, None)
1509
 
 
1510
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1511
 
        self.assertEqual("old-id", old_tree.get_revision_id())
1512
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
1513
 
        self.assertEqual("new-id", new_tree.get_revision_id())
1514
 
        self.assertEqual(tree.branch.base, old_branch.base)
1515
 
        self.assertEqual(tree.branch.base, new_branch.base)
1516
 
        self.assertIs(None, specific_files)
1517
 
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1518
 
 
1519
 
 
1520
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1521
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1522
 
    deprecated get_trees_and_branches_to_diff function.
1523
 
    """
1524
 
 
1525
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1526
 
        return self.applyDeprecated(
1527
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1528
 
            path_list, revision_specs, old_url, new_url)