← 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: Martin
  • Date: 2009-11-28 00:48:03 UTC
  • mto: This revision was merged to the branch mainline in revision 4853.
  • Revision ID: gzlist@googlemail.com-20091128004803-nirz54wazyj0waf8
MergeDirective.from_lines claims to want an iterable but currently requires a list, rewrite so it really wants an iterable

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
22
 
 
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,
34
 
    )
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
 
from bzrlib.tests import (
39
 
    features,
40
 
    )
 
23
from tempfile import TemporaryFile
 
24
 
 
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,
 
35
    get_trees_and_branches_to_diff,
 
36
    )
 
37
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
 
38
import bzrlib.osutils as osutils
 
39
import bzrlib.revision as _mod_revision
 
40
import bzrlib.transform as transform
 
41
import bzrlib.patiencediff
 
42
import bzrlib._patiencediff_py
 
43
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
44
                          TestCaseInTempDir, TestSkipped)
 
45
from bzrlib.revisiontree import RevisionTree
 
46
from bzrlib.revisionspec import RevisionSpec
 
47
 
 
48
 
 
49
class _AttribFeature(Feature):
 
50
 
 
51
    def _probe(self):
 
52
        if (sys.platform not in ('cygwin', 'win32')):
 
53
            return False
 
54
        try:
 
55
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
 
56
        except OSError, e:
 
57
            return False
 
58
        return (0 == proc.wait())
 
59
 
 
60
    def feature_name(self):
 
61
        return 'attrib Windows command-line tool'
 
62
 
 
63
AttribFeature = _AttribFeature()
 
64
 
 
65
 
 
66
class _CompiledPatienceDiffFeature(Feature):
 
67
 
 
68
    def _probe(self):
 
69
        try:
 
70
            import bzrlib._patiencediff_c
 
71
        except ImportError:
 
72
            return False
 
73
        return True
 
74
 
 
75
    def feature_name(self):
 
76
        return 'bzrlib._patiencediff_c'
 
77
 
 
78
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
41
79
 
42
80
 
43
81
def udiff_lines(old, new, allow_binary=False):
44
82
    output = StringIO()
45
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
83
    internal_diff('old', old, 'new', new, output, allow_binary)
46
84
    output.seek(0, 0)
47
85
    return output.readlines()
48
86
 
52
90
        # StringIO has no fileno, so it tests a different codepath
53
91
        output = StringIO()
54
92
    else:
55
 
        output = tempfile.TemporaryFile()
 
93
        output = TemporaryFile()
56
94
    try:
57
 
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
58
 
    except errors.NoDiff:
59
 
        raise tests.TestSkipped('external "diff" not present to test')
 
95
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
96
    except NoDiff:
 
97
        raise TestSkipped('external "diff" not present to test')
60
98
    output.seek(0, 0)
61
99
    lines = output.readlines()
62
100
    output.close()
63
101
    return lines
64
102
 
65
103
 
66
 
class TestDiff(tests.TestCase):
 
104
class TestDiff(TestCase):
67
105
 
68
106
    def test_add_nl(self):
69
107
        """diff generates a valid diff for patches that add a newline"""
105
143
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
106
144
 
107
145
    def test_binary_lines(self):
108
 
        empty = []
109
 
        uni_lines = [1023 * 'a' + '\x00']
110
 
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
111
 
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
112
 
        udiff_lines(uni_lines , empty, allow_binary=True)
113
 
        udiff_lines(empty, uni_lines, allow_binary=True)
 
146
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
147
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
148
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
149
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
114
150
 
115
151
    def test_external_diff(self):
116
152
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
126
162
        self.check_patch(lines)
127
163
 
128
164
    def test_external_diff_binary_lang_c(self):
 
165
        old_env = {}
129
166
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
130
 
            self.overrideEnv(lang, 'C')
131
 
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
132
 
        # Older versions of diffutils say "Binary files", newer
133
 
        # versions just say "Files".
134
 
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
135
 
        self.assertEquals(lines[1:], ['\n'])
 
167
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
168
        try:
 
169
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
170
            # Older versions of diffutils say "Binary files", newer
 
171
            # versions just say "Files".
 
172
            self.assertContainsRe(lines[0],
 
173
                                  '(Binary f|F)iles old and new differ\n')
 
174
            self.assertEquals(lines[1:], ['\n'])
 
175
        finally:
 
176
            for lang, old_val in old_env.iteritems():
 
177
                osutils.set_or_unset_env(lang, old_val)
136
178
 
137
179
    def test_no_external_diff(self):
138
180
        """Check that NoDiff is raised when diff is not available"""
139
 
        # Make sure no 'diff' command is available
140
 
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
141
 
        self.overrideEnv('PATH', '')
142
 
        self.assertRaises(errors.NoDiff, diff.external_diff,
143
 
                          'old', ['boo\n'], 'new', ['goo\n'],
144
 
                          StringIO(), diff_opts=['-u'])
 
181
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
182
        orig_path = os.environ['PATH']
 
183
        try:
 
184
            os.environ['PATH'] = ''
 
185
            self.assertRaises(NoDiff, external_diff,
 
186
                              'old', ['boo\n'], 'new', ['goo\n'],
 
187
                              StringIO(), diff_opts=['-u'])
 
188
        finally:
 
189
            os.environ['PATH'] = orig_path
145
190
 
146
191
    def test_internal_diff_default(self):
147
192
        # Default internal diff encoding is utf8
148
193
        output = StringIO()
149
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
150
 
                           u'new_\xe5', ['new_text\n'], output)
 
194
        internal_diff(u'old_\xb5', ['old_text\n'],
 
195
                    u'new_\xe5', ['new_text\n'], output)
151
196
        lines = output.getvalue().splitlines(True)
152
197
        self.check_patch(lines)
153
198
        self.assertEquals(['--- old_\xc2\xb5\n',
161
206
 
162
207
    def test_internal_diff_utf8(self):
163
208
        output = StringIO()
164
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
165
 
                           u'new_\xe5', ['new_text\n'], output,
166
 
                           path_encoding='utf8')
 
209
        internal_diff(u'old_\xb5', ['old_text\n'],
 
210
                    u'new_\xe5', ['new_text\n'], output,
 
211
                    path_encoding='utf8')
167
212
        lines = output.getvalue().splitlines(True)
168
213
        self.check_patch(lines)
169
214
        self.assertEquals(['--- old_\xc2\xb5\n',
177
222
 
178
223
    def test_internal_diff_iso_8859_1(self):
179
224
        output = StringIO()
180
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
181
 
                           u'new_\xe5', ['new_text\n'], output,
182
 
                           path_encoding='iso-8859-1')
 
225
        internal_diff(u'old_\xb5', ['old_text\n'],
 
226
                    u'new_\xe5', ['new_text\n'], output,
 
227
                    path_encoding='iso-8859-1')
183
228
        lines = output.getvalue().splitlines(True)
184
229
        self.check_patch(lines)
185
230
        self.assertEquals(['--- old_\xb5\n',
193
238
 
194
239
    def test_internal_diff_no_content(self):
195
240
        output = StringIO()
196
 
        diff.internal_diff(u'old', [], u'new', [], output)
 
241
        internal_diff(u'old', [], u'new', [], output)
197
242
        self.assertEqual('', output.getvalue())
198
243
 
199
244
    def test_internal_diff_no_changes(self):
200
245
        output = StringIO()
201
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
202
 
                           u'new', ['text\n', 'contents\n'],
203
 
                           output)
 
246
        internal_diff(u'old', ['text\n', 'contents\n'],
 
247
                      u'new', ['text\n', 'contents\n'],
 
248
                      output)
204
249
        self.assertEqual('', output.getvalue())
205
250
 
206
251
    def test_internal_diff_returns_bytes(self):
207
252
        import StringIO
208
253
        output = StringIO.StringIO()
209
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
210
 
                            u'new_\xe5', ['new_text\n'], output)
211
 
        self.assertIsInstance(output.getvalue(), str,
 
254
        internal_diff(u'old_\xb5', ['old_text\n'],
 
255
                    u'new_\xe5', ['new_text\n'], output)
 
256
        self.failUnless(isinstance(output.getvalue(), str),
212
257
            'internal_diff should return bytestrings')
213
258
 
214
259
 
215
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
260
class TestDiffFiles(TestCaseInTempDir):
216
261
 
217
262
    def test_external_diff_binary(self):
218
263
        """The output when using external diff should use diff's i18n error"""
231
276
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
232
277
 
233
278
 
234
 
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
235
 
    output = StringIO()
236
 
    if working_tree is not None:
237
 
        extra_trees = (working_tree,)
238
 
    else:
239
 
        extra_trees = ()
240
 
    diff.show_diff_trees(tree1, tree2, output,
241
 
        specific_files=specific_files,
242
 
        extra_trees=extra_trees, old_label='old/',
243
 
        new_label='new/')
244
 
    return output.getvalue()
245
 
 
246
 
 
247
 
class TestDiffDates(tests.TestCaseWithTransport):
 
279
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
280
    """Has a helper for running show_diff_trees"""
 
281
 
 
282
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
283
        output = StringIO()
 
284
        if working_tree is not None:
 
285
            extra_trees = (working_tree,)
 
286
        else:
 
287
            extra_trees = ()
 
288
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
289
                        extra_trees=extra_trees, old_label='old/',
 
290
                        new_label='new/')
 
291
        return output.getvalue()
 
292
 
 
293
 
 
294
class TestDiffDates(TestShowDiffTreesHelper):
248
295
 
249
296
    def setUp(self):
250
297
        super(TestDiffDates, self).setUp()
285
332
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
286
333
 
287
334
    def test_diff_rev_tree_working_tree(self):
288
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
335
        output = self.get_diff(self.wt.basis_tree(), self.wt)
289
336
        # note that the date for old/file1 is from rev 2 rather than from
290
337
        # the basis revision (rev 4)
291
338
        self.assertEqualDiff(output, '''\
301
348
    def test_diff_rev_tree_rev_tree(self):
302
349
        tree1 = self.b.repository.revision_tree('rev-2')
303
350
        tree2 = self.b.repository.revision_tree('rev-3')
304
 
        output = get_diff_as_string(tree1, tree2)
 
351
        output = self.get_diff(tree1, tree2)
305
352
        self.assertEqualDiff(output, '''\
306
353
=== modified file 'file2'
307
354
--- old/file2\t2006-04-01 00:00:00 +0000
315
362
    def test_diff_add_files(self):
316
363
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
317
364
        tree2 = self.b.repository.revision_tree('rev-1')
318
 
        output = get_diff_as_string(tree1, tree2)
 
365
        output = self.get_diff(tree1, tree2)
319
366
        # the files have the epoch time stamp for the tree in which
320
367
        # they don't exist.
321
368
        self.assertEqualDiff(output, '''\
336
383
    def test_diff_remove_files(self):
337
384
        tree1 = self.b.repository.revision_tree('rev-3')
338
385
        tree2 = self.b.repository.revision_tree('rev-4')
339
 
        output = get_diff_as_string(tree1, tree2)
 
386
        output = self.get_diff(tree1, tree2)
340
387
        # the file has the epoch time stamp for the tree in which
341
388
        # it doesn't exist.
342
389
        self.assertEqualDiff(output, '''\
353
400
        self.wt.rename_one('file1', 'file1b')
354
401
        old_tree = self.b.repository.revision_tree('rev-1')
355
402
        new_tree = self.b.repository.revision_tree('rev-4')
356
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
 
403
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
357
404
                            working_tree=self.wt)
358
405
        self.assertContainsRe(out, 'file1\t')
359
406
 
365
412
        self.wt.rename_one('file1', 'dir1/file1')
366
413
        old_tree = self.b.repository.revision_tree('rev-1')
367
414
        new_tree = self.b.repository.revision_tree('rev-4')
368
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
 
415
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
369
416
                            working_tree=self.wt)
370
417
        self.assertContainsRe(out, 'file1\t')
371
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
 
418
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
372
419
                            working_tree=self.wt)
373
420
        self.assertNotContainsRe(out, 'file1\t')
374
421
 
375
422
 
376
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
423
 
 
424
class TestShowDiffTrees(TestShowDiffTreesHelper):
377
425
    """Direct tests for show_diff_trees"""
378
426
 
379
427
    def test_modified_file(self):
384
432
        tree.commit('one', rev_id='rev-1')
385
433
 
386
434
        self.build_tree_contents([('tree/file', 'new contents\n')])
387
 
        d = get_diff_as_string(tree.basis_tree(), tree)
388
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
389
 
        self.assertContainsRe(d, '--- old/file\t')
390
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
391
 
        self.assertContainsRe(d, '-contents\n'
392
 
                                 '\\+new contents\n')
 
435
        diff = self.get_diff(tree.basis_tree(), tree)
 
436
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
437
        self.assertContainsRe(diff, '--- old/file\t')
 
438
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
439
        self.assertContainsRe(diff, '-contents\n'
 
440
                                    '\\+new contents\n')
393
441
 
394
442
    def test_modified_file_in_renamed_dir(self):
395
443
        """Test when a file is modified in a renamed directory."""
401
449
 
402
450
        tree.rename_one('dir', 'other')
403
451
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
404
 
        d = get_diff_as_string(tree.basis_tree(), tree)
405
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
406
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
452
        diff = self.get_diff(tree.basis_tree(), tree)
 
453
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
454
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
407
455
        # XXX: This is technically incorrect, because it used to be at another
408
456
        # location. What to do?
409
 
        self.assertContainsRe(d, '--- old/dir/file\t')
410
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
411
 
        self.assertContainsRe(d, '-contents\n'
412
 
                                 '\\+new contents\n')
 
457
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
458
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
459
        self.assertContainsRe(diff, '-contents\n'
 
460
                                    '\\+new contents\n')
413
461
 
414
462
    def test_renamed_directory(self):
415
463
        """Test when only a directory is only renamed."""
420
468
        tree.commit('one', rev_id='rev-1')
421
469
 
422
470
        tree.rename_one('dir', 'newdir')
423
 
        d = get_diff_as_string(tree.basis_tree(), tree)
 
471
        diff = self.get_diff(tree.basis_tree(), tree)
424
472
        # Renaming a directory should be a single "you renamed this dir" even
425
473
        # when there are files inside.
426
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
474
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
427
475
 
428
476
    def test_renamed_file(self):
429
477
        """Test when a file is only renamed."""
433
481
        tree.commit('one', rev_id='rev-1')
434
482
 
435
483
        tree.rename_one('file', 'newname')
436
 
        d = get_diff_as_string(tree.basis_tree(), tree)
437
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
484
        diff = self.get_diff(tree.basis_tree(), tree)
 
485
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
438
486
        # We shouldn't have a --- or +++ line, because there is no content
439
487
        # change
440
 
        self.assertNotContainsRe(d, '---')
 
488
        self.assertNotContainsRe(diff, '---')
441
489
 
442
490
    def test_renamed_and_modified_file(self):
443
491
        """Test when a file is only renamed."""
448
496
 
449
497
        tree.rename_one('file', 'newname')
450
498
        self.build_tree_contents([('tree/newname', 'new contents\n')])
451
 
        d = get_diff_as_string(tree.basis_tree(), tree)
452
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
453
 
        self.assertContainsRe(d, '--- old/file\t')
454
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
455
 
        self.assertContainsRe(d, '-contents\n'
456
 
                                 '\\+new contents\n')
 
499
        diff = self.get_diff(tree.basis_tree(), tree)
 
500
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
501
        self.assertContainsRe(diff, '--- old/file\t')
 
502
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
503
        self.assertContainsRe(diff, '-contents\n'
 
504
                                    '\\+new contents\n')
457
505
 
458
506
 
459
507
    def test_internal_diff_exec_property(self):
478
526
        tree.rename_one('c', 'new-c')
479
527
        tree.rename_one('d', 'new-d')
480
528
 
481
 
        d = get_diff_as_string(tree.basis_tree(), tree)
482
 
 
483
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
484
 
                                  ".*\+x to -x.*\)")
485
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
486
 
                                  ".*-x to \+x.*\)")
487
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
488
 
                                  ".*\+x to -x.*\)")
489
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
490
 
                                  ".*-x to \+x.*\)")
491
 
        self.assertNotContainsRe(d, r"file 'e'")
492
 
        self.assertNotContainsRe(d, r"file 'f'")
 
529
        diff = self.get_diff(tree.basis_tree(), tree)
 
530
 
 
531
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
532
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
533
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
534
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
535
        self.assertNotContainsRe(diff, r"file 'e'")
 
536
        self.assertNotContainsRe(diff, r"file 'f'")
 
537
 
493
538
 
494
539
    def test_binary_unicode_filenames(self):
495
540
        """Test that contents of files are *not* encoded in UTF-8 when there
496
541
        is a binary file in the diff.
497
542
        """
498
543
        # See https://bugs.launchpad.net/bugs/110092.
499
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
544
        self.requireFeature(tests.UnicodeFilenameFeature)
500
545
 
501
546
        # This bug isn't triggered with cStringIO.
502
547
        from StringIO import StringIO
510
555
        tree.add([alpha], ['file-id'])
511
556
        tree.add([omega], ['file-id-2'])
512
557
        diff_content = StringIO()
513
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
514
 
        d = diff_content.getvalue()
515
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
516
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
517
 
                              % (alpha_utf8, alpha_utf8))
518
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
519
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
520
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
558
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
559
        diff = diff_content.getvalue()
 
560
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
561
        self.assertContainsRe(
 
562
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
563
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
564
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
565
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
521
566
 
522
567
    def test_unicode_filename(self):
523
568
        """Test when the filename are unicode."""
524
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
569
        self.requireFeature(tests.UnicodeFilenameFeature)
525
570
 
526
571
        alpha, omega = u'\u03b1', u'\u03c9'
527
572
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
542
587
        tree.add(['add_'+alpha], ['file-id'])
543
588
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
544
589
 
545
 
        d = get_diff_as_string(tree.basis_tree(), tree)
546
 
        self.assertContainsRe(d,
 
590
        diff = self.get_diff(tree.basis_tree(), tree)
 
591
        self.assertContainsRe(diff,
547
592
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
548
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
549
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
550
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
551
 
 
552
 
    def test_unicode_filename_path_encoding(self):
553
 
        """Test for bug #382699: unicode filenames on Windows should be shown
554
 
        in user encoding.
555
 
        """
556
 
        self.requireFeature(features.UnicodeFilenameFeature)
557
 
        # The word 'test' in Russian
558
 
        _russian_test = u'\u0422\u0435\u0441\u0442'
559
 
        directory = _russian_test + u'/'
560
 
        test_txt = _russian_test + u'.txt'
561
 
        u1234 = u'\u1234.txt'
562
 
 
563
 
        tree = self.make_branch_and_tree('.')
564
 
        self.build_tree_contents([
565
 
            (test_txt, 'foo\n'),
566
 
            (u1234, 'foo\n'),
567
 
            (directory, None),
568
 
            ])
569
 
        tree.add([test_txt, u1234, directory])
570
 
 
571
 
        sio = StringIO()
572
 
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
573
 
            path_encoding='cp1251')
574
 
 
575
 
        output = subst_dates(sio.getvalue())
576
 
        shouldbe = ('''\
577
 
=== added directory '%(directory)s'
578
 
=== added file '%(test_txt)s'
579
 
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
580
 
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
581
 
@@ -0,0 +1,1 @@
582
 
+foo
583
 
 
584
 
=== added file '?.txt'
585
 
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
586
 
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
587
 
@@ -0,0 +1,1 @@
588
 
+foo
589
 
 
590
 
''' % {'directory': _russian_test.encode('cp1251'),
591
 
       'test_txt': test_txt.encode('cp1251'),
592
 
      })
593
 
        self.assertEqualDiff(output, shouldbe)
594
 
 
595
 
 
596
 
class DiffWasIs(diff.DiffPath):
 
593
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
594
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
595
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
596
 
 
597
 
 
598
class DiffWasIs(DiffPath):
597
599
 
598
600
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
599
601
        self.to_file.write('was: ')
603
605
        pass
604
606
 
605
607
 
606
 
class TestDiffTree(tests.TestCaseWithTransport):
 
608
class TestDiffTree(TestCaseWithTransport):
607
609
 
608
610
    def setUp(self):
609
 
        super(TestDiffTree, self).setUp()
 
611
        TestCaseWithTransport.setUp(self)
610
612
        self.old_tree = self.make_branch_and_tree('old-tree')
611
613
        self.old_tree.lock_write()
612
614
        self.addCleanup(self.old_tree.unlock)
613
615
        self.new_tree = self.make_branch_and_tree('new-tree')
614
616
        self.new_tree.lock_write()
615
617
        self.addCleanup(self.new_tree.unlock)
616
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
618
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
617
619
 
618
620
    def test_diff_text(self):
619
621
        self.build_tree_contents([('old-tree/olddir/',),
624
626
                                  ('new-tree/newdir/newfile', 'new\n')])
625
627
        self.new_tree.add('newdir')
626
628
        self.new_tree.add('newdir/newfile', 'file-id')
627
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
629
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
628
630
        differ.diff_text('file-id', None, 'old label', 'new label')
629
631
        self.assertEqual(
630
632
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
659
661
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
660
662
 
661
663
    def test_diff_symlink(self):
662
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
664
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
663
665
        differ.diff_symlink('old target', None)
664
666
        self.assertEqual("=== target was 'old target'\n",
665
667
                         differ.to_file.getvalue())
666
668
 
667
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
669
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
668
670
        differ.diff_symlink(None, 'new target')
669
671
        self.assertEqual("=== target is 'new target'\n",
670
672
                         differ.to_file.getvalue())
671
673
 
672
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
674
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
673
675
        differ.diff_symlink('old target', 'new target')
674
676
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
675
677
                         differ.to_file.getvalue())
690
692
             ' \@\@\n-old\n\+new\n\n')
691
693
 
692
694
    def test_diff_kind_change(self):
693
 
        self.requireFeature(features.SymlinkFeature)
 
695
        self.requireFeature(tests.SymlinkFeature)
694
696
        self.build_tree_contents([('old-tree/olddir/',),
695
697
                                  ('old-tree/olddir/oldfile', 'old\n')])
696
698
        self.old_tree.add('olddir')
725
727
 
726
728
    def test_register_diff(self):
727
729
        self.create_old_new()
728
 
        old_diff_factories = diff.DiffTree.diff_factories
729
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
730
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
730
        old_diff_factories = DiffTree.diff_factories
 
731
        DiffTree.diff_factories=old_diff_factories[:]
 
732
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
731
733
        try:
732
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
734
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
733
735
        finally:
734
 
            diff.DiffTree.diff_factories = old_diff_factories
 
736
            DiffTree.diff_factories = old_diff_factories
735
737
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
736
738
        self.assertNotContainsRe(
737
739
            differ.to_file.getvalue(),
742
744
 
743
745
    def test_extra_factories(self):
744
746
        self.create_old_new()
745
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
746
 
                               extra_factories=[DiffWasIs.from_diff_tree])
 
747
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
748
                            extra_factories=[DiffWasIs.from_diff_tree])
747
749
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
748
750
        self.assertNotContainsRe(
749
751
            differ.to_file.getvalue(),
762
764
            '.*a-file(.|\n)*b-file')
763
765
 
764
766
 
765
 
class TestPatienceDiffLib(tests.TestCase):
 
767
class TestPatienceDiffLib(TestCase):
766
768
 
767
769
    def setUp(self):
768
770
        super(TestPatienceDiffLib, self).setUp()
769
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
770
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
771
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
772
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
771
773
        self._PatienceSequenceMatcher = \
772
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
774
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
773
775
 
774
776
    def test_diff_unicode_string(self):
775
777
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
1082
1084
                 'how are you today?\n']
1083
1085
        txt_b = ['hello there\n',
1084
1086
                 'how are you today?\n']
1085
 
        unified_diff = patiencediff.unified_diff
 
1087
        unified_diff = bzrlib.patiencediff.unified_diff
1086
1088
        psm = self._PatienceSequenceMatcher
1087
1089
        self.assertEquals(['--- \n',
1088
1090
                           '+++ \n',
1136
1138
                 'how are you today?\n']
1137
1139
        txt_b = ['hello there\n',
1138
1140
                 'how are you today?\n']
1139
 
        unified_diff = patiencediff.unified_diff
 
1141
        unified_diff = bzrlib.patiencediff.unified_diff
1140
1142
        psm = self._PatienceSequenceMatcher
1141
1143
        self.assertEquals(['--- a\t2008-08-08\n',
1142
1144
                           '+++ b\t2008-09-09\n',
1154
1156
 
1155
1157
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1156
1158
 
1157
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1159
    _test_needs_features = [CompiledPatienceDiffFeature]
1158
1160
 
1159
1161
    def setUp(self):
1160
1162
        super(TestPatienceDiffLib_c, self).setUp()
1161
 
        from bzrlib import _patiencediff_c
1162
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1163
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1163
        import bzrlib._patiencediff_c
 
1164
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1165
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1164
1166
        self._PatienceSequenceMatcher = \
1165
 
            _patiencediff_c.PatienceSequenceMatcher_c
 
1167
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1166
1168
 
1167
1169
    def test_unhashable(self):
1168
1170
        """We should get a proper exception here."""
1178
1180
                                         None, ['valid'], ['valid', []])
1179
1181
 
1180
1182
 
1181
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1183
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1182
1184
 
1183
1185
    def setUp(self):
1184
1186
        super(TestPatienceDiffLibFiles, self).setUp()
1185
1187
        self._PatienceSequenceMatcher = \
1186
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
1188
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1187
1189
 
1188
1190
    def test_patience_unified_diff_files(self):
1189
1191
        txt_a = ['hello there\n',
1194
1196
        open('a1', 'wb').writelines(txt_a)
1195
1197
        open('b1', 'wb').writelines(txt_b)
1196
1198
 
1197
 
        unified_diff_files = patiencediff.unified_diff_files
 
1199
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1198
1200
        psm = self._PatienceSequenceMatcher
1199
1201
        self.assertEquals(['--- a1\n',
1200
1202
                           '+++ b1\n',
1250
1252
 
1251
1253
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1252
1254
 
1253
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1255
    _test_needs_features = [CompiledPatienceDiffFeature]
1254
1256
 
1255
1257
    def setUp(self):
1256
1258
        super(TestPatienceDiffLibFiles_c, self).setUp()
1257
 
        from bzrlib import _patiencediff_c
 
1259
        import bzrlib._patiencediff_c
1258
1260
        self._PatienceSequenceMatcher = \
1259
 
            _patiencediff_c.PatienceSequenceMatcher_c
1260
 
 
1261
 
 
1262
 
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1261
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1262
 
 
1263
 
 
1264
class TestUsingCompiledIfAvailable(TestCase):
1263
1265
 
1264
1266
    def test_PatienceSequenceMatcher(self):
1265
 
        if features.compiled_patiencediff_feature.available():
 
1267
        if CompiledPatienceDiffFeature.available():
1266
1268
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1267
1269
            self.assertIs(PatienceSequenceMatcher_c,
1268
 
                          patiencediff.PatienceSequenceMatcher)
 
1270
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1269
1271
        else:
1270
1272
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1271
1273
            self.assertIs(PatienceSequenceMatcher_py,
1272
 
                          patiencediff.PatienceSequenceMatcher)
 
1274
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1273
1275
 
1274
1276
    def test_unique_lcs(self):
1275
 
        if features.compiled_patiencediff_feature.available():
 
1277
        if CompiledPatienceDiffFeature.available():
1276
1278
            from bzrlib._patiencediff_c import unique_lcs_c
1277
1279
            self.assertIs(unique_lcs_c,
1278
 
                          patiencediff.unique_lcs)
 
1280
                          bzrlib.patiencediff.unique_lcs)
1279
1281
        else:
1280
1282
            from bzrlib._patiencediff_py import unique_lcs_py
1281
1283
            self.assertIs(unique_lcs_py,
1282
 
                          patiencediff.unique_lcs)
 
1284
                          bzrlib.patiencediff.unique_lcs)
1283
1285
 
1284
1286
    def test_recurse_matches(self):
1285
 
        if features.compiled_patiencediff_feature.available():
 
1287
        if CompiledPatienceDiffFeature.available():
1286
1288
            from bzrlib._patiencediff_c import recurse_matches_c
1287
1289
            self.assertIs(recurse_matches_c,
1288
 
                          patiencediff.recurse_matches)
 
1290
                          bzrlib.patiencediff.recurse_matches)
1289
1291
        else:
1290
1292
            from bzrlib._patiencediff_py import recurse_matches_py
1291
1293
            self.assertIs(recurse_matches_py,
1292
 
                          patiencediff.recurse_matches)
1293
 
 
1294
 
 
1295
 
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1294
                          bzrlib.patiencediff.recurse_matches)
 
1295
 
 
1296
 
 
1297
class TestDiffFromTool(TestCaseWithTransport):
1296
1298
 
1297
1299
    def test_from_string(self):
1298
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1300
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1299
1301
        self.addCleanup(diff_obj.finish)
1300
 
        self.assertEqual(['diff', '@old_path', '@new_path'],
 
1302
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
1301
1303
            diff_obj.command_template)
1302
1304
 
1303
1305
    def test_from_string_u5(self):
1304
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1305
 
                                                 None, None, None)
 
1306
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
1306
1307
        self.addCleanup(diff_obj.finish)
1307
 
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
 
1308
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
1308
1309
                         diff_obj.command_template)
1309
1310
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1310
1311
                         diff_obj._get_command('old-path', 'new-path'))
1311
1312
 
1312
 
    def test_from_string_path_with_backslashes(self):
1313
 
        self.requireFeature(features.backslashdir_feature)
1314
 
        tool = 'C:\\Tools\\Diff.exe'
1315
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1316
 
        self.addCleanup(diff_obj.finish)
1317
 
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1318
 
                         diff_obj.command_template)
1319
 
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1320
 
                         diff_obj._get_command('old-path', 'new-path'))
1321
 
 
1322
1313
    def test_execute(self):
1323
1314
        output = StringIO()
1324
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1325
 
                                      'print "@old_path @new_path"'],
1326
 
                                     None, None, output)
 
1315
        diff_obj = DiffFromTool(['python', '-c',
 
1316
                                 'print "%(old_path)s %(new_path)s"'],
 
1317
                                None, None, output)
1327
1318
        self.addCleanup(diff_obj.finish)
1328
1319
        diff_obj._execute('old', 'new')
1329
1320
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1330
1321
 
1331
1322
    def test_excute_missing(self):
1332
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1333
 
                                     None, None, None)
 
1323
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1324
                                None, None, None)
1334
1325
        self.addCleanup(diff_obj.finish)
1335
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1336
 
                              'old', 'new')
 
1326
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1327
                              'new')
1337
1328
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1338
1329
                         ' on this machine', str(e))
1339
1330
 
1340
1331
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1341
 
        self.requireFeature(features.AttribFeature)
 
1332
        self.requireFeature(AttribFeature)
1342
1333
        output = StringIO()
1343
1334
        tree = self.make_branch_and_tree('tree')
1344
1335
        self.build_tree_contents([('tree/file', 'content')])
1346
1337
        tree.commit('old tree')
1347
1338
        tree.lock_read()
1348
1339
        self.addCleanup(tree.unlock)
1349
 
        basis_tree = tree.basis_tree()
1350
 
        basis_tree.lock_read()
1351
 
        self.addCleanup(basis_tree.unlock)
1352
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1353
 
                                      'print "@old_path @new_path"'],
1354
 
                                     basis_tree, tree, output)
 
1340
        diff_obj = DiffFromTool(['python', '-c',
 
1341
                                 'print "%(old_path)s %(new_path)s"'],
 
1342
                                tree, tree, output)
1355
1343
        diff_obj._prepare_files('file-id', 'file', 'file')
1356
 
        # The old content should be readonly
1357
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1358
 
                                    r'R.*old\\file$')
1359
 
        # The new content should use the tree object, not a 'new' file anymore
1360
 
        self.assertEndsWith(tree.basedir, 'work/tree')
1361
 
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
 
1344
        self.assertReadableByAttrib(diff_obj._root, 'old\\file', r'old\\file')
 
1345
        self.assertReadableByAttrib(diff_obj._root, 'new\\file', r'new\\file')
1362
1346
 
1363
1347
    def assertReadableByAttrib(self, cwd, relpath, regex):
1364
1348
        proc = subprocess.Popen(['attrib', relpath],
1365
1349
                                stdout=subprocess.PIPE,
1366
1350
                                cwd=cwd)
1367
 
        (result, err) = proc.communicate()
1368
 
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
 
1351
        proc.wait()
 
1352
        result = proc.stdout.read()
 
1353
        self.assertContainsRe(result, regex)
1369
1354
 
1370
1355
    def test_prepare_files(self):
1371
1356
        output = StringIO()
1374
1359
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1375
1360
        tree.add('oldname', 'file-id')
1376
1361
        tree.add('oldname2', 'file2-id')
1377
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1378
 
        tree.commit('old tree', timestamp=315532800)
 
1362
        tree.commit('old tree', timestamp=0)
1379
1363
        tree.rename_one('oldname', 'newname')
1380
1364
        tree.rename_one('oldname2', 'newname2')
1381
1365
        self.build_tree_contents([('tree/newname', 'newcontent')])
1385
1369
        self.addCleanup(old_tree.unlock)
1386
1370
        tree.lock_read()
1387
1371
        self.addCleanup(tree.unlock)
1388
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1389
 
                                      'print "@old_path @new_path"'],
1390
 
                                     old_tree, tree, output)
 
1372
        diff_obj = DiffFromTool(['python', '-c',
 
1373
                                 'print "%(old_path)s %(new_path)s"'],
 
1374
                                old_tree, tree, output)
1391
1375
        self.addCleanup(diff_obj.finish)
1392
1376
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1393
1377
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1394
1378
                                                     'newname')
1395
1379
        self.assertContainsRe(old_path, 'old/oldname$')
1396
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
1397
 
        self.assertContainsRe(new_path, 'tree/newname$')
 
1380
        self.assertEqual(0, os.stat(old_path).st_mtime)
 
1381
        self.assertContainsRe(new_path, 'new/newname$')
1398
1382
        self.assertFileEqual('oldcontent', old_path)
1399
1383
        self.assertFileEqual('newcontent', new_path)
1400
1384
        if osutils.host_os_dereferences_symlinks():
1403
1387
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1404
1388
 
1405
1389
 
1406
 
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
1407
 
 
1408
 
    def test_encodable_filename(self):
1409
 
        # Just checks file path for external diff tool.
1410
 
        # We cannot change CPython's internal encoding used by os.exec*.
1411
 
        import sys
1412
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1413
 
                                    None, None, None)
1414
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1415
 
            encoding = scenario['encoding']
1416
 
            dirname  = scenario['info']['directory']
1417
 
            filename = scenario['info']['filename']
1418
 
 
1419
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1420
 
            relpath = dirname + u'/' + filename
1421
 
            fullpath = diffobj._safe_filename('safe', relpath)
1422
 
            self.assertEqual(
1423
 
                    fullpath,
1424
 
                    fullpath.encode(encoding).decode(encoding)
1425
 
                    )
1426
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1427
 
 
1428
 
    def test_unencodable_filename(self):
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
 
            if encoding == 'iso-8859-1':
1438
 
                encoding = 'iso-8859-2'
1439
 
            else:
1440
 
                encoding = 'iso-8859-1'
1441
 
 
1442
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1443
 
            relpath = dirname + u'/' + filename
1444
 
            fullpath = diffobj._safe_filename('safe', relpath)
1445
 
            self.assertEqual(
1446
 
                    fullpath,
1447
 
                    fullpath.encode(encoding).decode(encoding)
1448
 
                    )
1449
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1450
 
 
1451
 
 
1452
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1453
 
 
1454
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1455
 
        """Call get_trees_and_branches_to_diff_locked."""
1456
 
        return diff.get_trees_and_branches_to_diff_locked(
1457
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
 
1390
class TestGetTreesAndBranchesToDiff(TestCaseWithTransport):
1458
1391
 
1459
1392
    def test_basic(self):
1460
1393
        tree = self.make_branch_and_tree('tree')
1461
1394
        (old_tree, new_tree,
1462
1395
         old_branch, new_branch,
1463
 
         specific_files, extra_trees) = self.call_gtabtd(
1464
 
             ['tree'], None, None, None)
 
1396
         specific_files, extra_trees) = \
 
1397
            get_trees_and_branches_to_diff(['tree'], None, None, None)
1465
1398
 
1466
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1467
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1468
 
                         old_tree.get_revision_id())
 
1399
        self.assertIsInstance(old_tree, RevisionTree)
 
1400
        #print dir (old_tree)
 
1401
        self.assertEqual(_mod_revision.NULL_REVISION, old_tree.get_revision_id())
1469
1402
        self.assertEqual(tree.basedir, new_tree.basedir)
1470
1403
        self.assertEqual(tree.branch.base, old_branch.base)
1471
1404
        self.assertEqual(tree.branch.base, new_branch.base)
1480
1413
        self.build_tree_contents([('tree/file', 'newcontent')])
1481
1414
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1482
1415
 
1483
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1484
 
                     revisionspec.RevisionSpec.from_string('2')]
 
1416
        revisions = [RevisionSpec.from_string('1'),
 
1417
                     RevisionSpec.from_string('2')]
1485
1418
        (old_tree, new_tree,
1486
1419
         old_branch, new_branch,
1487
 
         specific_files, extra_trees) = self.call_gtabtd(
1488
 
            ['tree'], revisions, None, None)
 
1420
         specific_files, extra_trees) = \
 
1421
            get_trees_and_branches_to_diff(['tree'], revisions, None, None)
1489
1422
 
1490
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1423
        self.assertIsInstance(old_tree, RevisionTree)
1491
1424
        self.assertEqual("old-id", old_tree.get_revision_id())
1492
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
 
1425
        self.assertIsInstance(new_tree, RevisionTree)
1493
1426
        self.assertEqual("new-id", new_tree.get_revision_id())
1494
1427
        self.assertEqual(tree.branch.base, old_branch.base)
1495
1428
        self.assertEqual(tree.branch.base, new_branch.base)