← 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: Robert Collins
  • Date: 2010-04-08 04:34:03 UTC
  • mfrom: (5138 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5139.
  • Revision ID: robertc@robertcollins.net-20100408043403-56z0d07vdqrx7f3t
Update bugfix for 528114 to trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
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,
 
35
    get_trees_and_branches_to_diff,
34
36
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features
37
 
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
 
39
 
 
40
 
class _AttribFeature(tests.Feature):
 
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
from bzrlib.tests.test_win32utils import BackslashDirSeparatorFeature
 
49
 
 
50
 
 
51
class _AttribFeature(Feature):
41
52
 
42
53
    def _probe(self):
43
54
        if (sys.platform not in ('cygwin', 'win32')):
60
71
 
61
72
def udiff_lines(old, new, allow_binary=False):
62
73
    output = StringIO()
63
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
74
    internal_diff('old', old, 'new', new, output, allow_binary)
64
75
    output.seek(0, 0)
65
76
    return output.readlines()
66
77
 
70
81
        # StringIO has no fileno, so it tests a different codepath
71
82
        output = StringIO()
72
83
    else:
73
 
        output = tempfile.TemporaryFile()
 
84
        output = TemporaryFile()
74
85
    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')
 
86
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
87
    except NoDiff:
 
88
        raise TestSkipped('external "diff" not present to test')
78
89
    output.seek(0, 0)
79
90
    lines = output.readlines()
80
91
    output.close()
81
92
    return lines
82
93
 
83
94
 
84
 
class TestDiff(tests.TestCase):
 
95
class TestDiff(TestCase):
85
96
 
86
97
    def test_add_nl(self):
87
98
        """diff generates a valid diff for patches that add a newline"""
123
134
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
124
135
 
125
136
    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)
 
137
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
138
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
139
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
140
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
132
141
 
133
142
    def test_external_diff(self):
134
143
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
164
173
        orig_path = os.environ['PATH']
165
174
        try:
166
175
            os.environ['PATH'] = ''
167
 
            self.assertRaises(errors.NoDiff, diff.external_diff,
 
176
            self.assertRaises(NoDiff, external_diff,
168
177
                              'old', ['boo\n'], 'new', ['goo\n'],
169
178
                              StringIO(), diff_opts=['-u'])
170
179
        finally:
173
182
    def test_internal_diff_default(self):
174
183
        # Default internal diff encoding is utf8
175
184
        output = StringIO()
176
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
177
 
                           u'new_\xe5', ['new_text\n'], output)
 
185
        internal_diff(u'old_\xb5', ['old_text\n'],
 
186
                    u'new_\xe5', ['new_text\n'], output)
178
187
        lines = output.getvalue().splitlines(True)
179
188
        self.check_patch(lines)
180
189
        self.assertEquals(['--- old_\xc2\xb5\n',
188
197
 
189
198
    def test_internal_diff_utf8(self):
190
199
        output = StringIO()
191
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
192
 
                           u'new_\xe5', ['new_text\n'], output,
193
 
                           path_encoding='utf8')
 
200
        internal_diff(u'old_\xb5', ['old_text\n'],
 
201
                    u'new_\xe5', ['new_text\n'], output,
 
202
                    path_encoding='utf8')
194
203
        lines = output.getvalue().splitlines(True)
195
204
        self.check_patch(lines)
196
205
        self.assertEquals(['--- old_\xc2\xb5\n',
204
213
 
205
214
    def test_internal_diff_iso_8859_1(self):
206
215
        output = StringIO()
207
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
208
 
                           u'new_\xe5', ['new_text\n'], output,
209
 
                           path_encoding='iso-8859-1')
 
216
        internal_diff(u'old_\xb5', ['old_text\n'],
 
217
                    u'new_\xe5', ['new_text\n'], output,
 
218
                    path_encoding='iso-8859-1')
210
219
        lines = output.getvalue().splitlines(True)
211
220
        self.check_patch(lines)
212
221
        self.assertEquals(['--- old_\xb5\n',
220
229
 
221
230
    def test_internal_diff_no_content(self):
222
231
        output = StringIO()
223
 
        diff.internal_diff(u'old', [], u'new', [], output)
 
232
        internal_diff(u'old', [], u'new', [], output)
224
233
        self.assertEqual('', output.getvalue())
225
234
 
226
235
    def test_internal_diff_no_changes(self):
227
236
        output = StringIO()
228
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
229
 
                           u'new', ['text\n', 'contents\n'],
230
 
                           output)
 
237
        internal_diff(u'old', ['text\n', 'contents\n'],
 
238
                      u'new', ['text\n', 'contents\n'],
 
239
                      output)
231
240
        self.assertEqual('', output.getvalue())
232
241
 
233
242
    def test_internal_diff_returns_bytes(self):
234
243
        import StringIO
235
244
        output = StringIO.StringIO()
236
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
237
 
                            u'new_\xe5', ['new_text\n'], output)
 
245
        internal_diff(u'old_\xb5', ['old_text\n'],
 
246
                    u'new_\xe5', ['new_text\n'], output)
238
247
        self.failUnless(isinstance(output.getvalue(), str),
239
248
            'internal_diff should return bytestrings')
240
249
 
241
250
 
242
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
251
class TestDiffFiles(TestCaseInTempDir):
243
252
 
244
253
    def test_external_diff_binary(self):
245
254
        """The output when using external diff should use diff's i18n error"""
258
267
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
259
268
 
260
269
 
261
 
class TestShowDiffTreesHelper(tests.TestCaseWithTransport):
 
270
class TestShowDiffTreesHelper(TestCaseWithTransport):
262
271
    """Has a helper for running show_diff_trees"""
263
272
 
264
273
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
267
276
            extra_trees = (working_tree,)
268
277
        else:
269
278
            extra_trees = ()
270
 
        diff.show_diff_trees(tree1, tree2, output,
271
 
                             specific_files=specific_files,
272
 
                             extra_trees=extra_trees, old_label='old/',
273
 
                             new_label='new/')
 
279
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
280
                        extra_trees=extra_trees, old_label='old/',
 
281
                        new_label='new/')
274
282
        return output.getvalue()
275
283
 
276
284
 
415
423
        tree.commit('one', rev_id='rev-1')
416
424
 
417
425
        self.build_tree_contents([('tree/file', 'new contents\n')])
418
 
        d = self.get_diff(tree.basis_tree(), tree)
419
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
420
 
        self.assertContainsRe(d, '--- old/file\t')
421
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
422
 
        self.assertContainsRe(d, '-contents\n'
423
 
                                 '\\+new contents\n')
 
426
        diff = self.get_diff(tree.basis_tree(), tree)
 
427
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
428
        self.assertContainsRe(diff, '--- old/file\t')
 
429
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
430
        self.assertContainsRe(diff, '-contents\n'
 
431
                                    '\\+new contents\n')
424
432
 
425
433
    def test_modified_file_in_renamed_dir(self):
426
434
        """Test when a file is modified in a renamed directory."""
432
440
 
433
441
        tree.rename_one('dir', 'other')
434
442
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
435
 
        d = self.get_diff(tree.basis_tree(), tree)
436
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
437
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
443
        diff = self.get_diff(tree.basis_tree(), tree)
 
444
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
445
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
438
446
        # XXX: This is technically incorrect, because it used to be at another
439
447
        # location. What to do?
440
 
        self.assertContainsRe(d, '--- old/dir/file\t')
441
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
442
 
        self.assertContainsRe(d, '-contents\n'
443
 
                                 '\\+new contents\n')
 
448
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
449
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
450
        self.assertContainsRe(diff, '-contents\n'
 
451
                                    '\\+new contents\n')
444
452
 
445
453
    def test_renamed_directory(self):
446
454
        """Test when only a directory is only renamed."""
451
459
        tree.commit('one', rev_id='rev-1')
452
460
 
453
461
        tree.rename_one('dir', 'newdir')
454
 
        d = self.get_diff(tree.basis_tree(), tree)
 
462
        diff = self.get_diff(tree.basis_tree(), tree)
455
463
        # Renaming a directory should be a single "you renamed this dir" even
456
464
        # when there are files inside.
457
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
465
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
458
466
 
459
467
    def test_renamed_file(self):
460
468
        """Test when a file is only renamed."""
464
472
        tree.commit('one', rev_id='rev-1')
465
473
 
466
474
        tree.rename_one('file', 'newname')
467
 
        d = self.get_diff(tree.basis_tree(), tree)
468
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
475
        diff = self.get_diff(tree.basis_tree(), tree)
 
476
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
469
477
        # We shouldn't have a --- or +++ line, because there is no content
470
478
        # change
471
 
        self.assertNotContainsRe(d, '---')
 
479
        self.assertNotContainsRe(diff, '---')
472
480
 
473
481
    def test_renamed_and_modified_file(self):
474
482
        """Test when a file is only renamed."""
479
487
 
480
488
        tree.rename_one('file', 'newname')
481
489
        self.build_tree_contents([('tree/newname', 'new contents\n')])
482
 
        d = self.get_diff(tree.basis_tree(), tree)
483
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
484
 
        self.assertContainsRe(d, '--- old/file\t')
485
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
486
 
        self.assertContainsRe(d, '-contents\n'
487
 
                                 '\\+new contents\n')
 
490
        diff = self.get_diff(tree.basis_tree(), tree)
 
491
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
492
        self.assertContainsRe(diff, '--- old/file\t')
 
493
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
494
        self.assertContainsRe(diff, '-contents\n'
 
495
                                    '\\+new contents\n')
488
496
 
489
497
 
490
498
    def test_internal_diff_exec_property(self):
509
517
        tree.rename_one('c', 'new-c')
510
518
        tree.rename_one('d', 'new-d')
511
519
 
512
 
        d = self.get_diff(tree.basis_tree(), tree)
513
 
 
514
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
515
 
                                  ".*\+x to -x.*\)")
516
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
517
 
                                  ".*-x to \+x.*\)")
518
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
519
 
                                  ".*\+x to -x.*\)")
520
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
521
 
                                  ".*-x to \+x.*\)")
522
 
        self.assertNotContainsRe(d, r"file 'e'")
523
 
        self.assertNotContainsRe(d, r"file 'f'")
 
520
        diff = self.get_diff(tree.basis_tree(), tree)
 
521
 
 
522
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
523
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
524
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
525
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
526
        self.assertNotContainsRe(diff, r"file 'e'")
 
527
        self.assertNotContainsRe(diff, r"file 'f'")
 
528
 
524
529
 
525
530
    def test_binary_unicode_filenames(self):
526
531
        """Test that contents of files are *not* encoded in UTF-8 when there
541
546
        tree.add([alpha], ['file-id'])
542
547
        tree.add([omega], ['file-id-2'])
543
548
        diff_content = StringIO()
544
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
545
 
        d = diff_content.getvalue()
546
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
547
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
548
 
                              % (alpha_utf8, alpha_utf8))
549
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
550
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
551
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
549
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
550
        diff = diff_content.getvalue()
 
551
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
552
        self.assertContainsRe(
 
553
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
554
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
555
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
556
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
552
557
 
553
558
    def test_unicode_filename(self):
554
559
        """Test when the filename are unicode."""
573
578
        tree.add(['add_'+alpha], ['file-id'])
574
579
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
575
580
 
576
 
        d = self.get_diff(tree.basis_tree(), tree)
577
 
        self.assertContainsRe(d,
 
581
        diff = self.get_diff(tree.basis_tree(), tree)
 
582
        self.assertContainsRe(diff,
578
583
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
579
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
580
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
581
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
582
 
 
583
 
    def test_unicode_filename_path_encoding(self):
584
 
        """Test for bug #382699: unicode filenames on Windows should be shown
585
 
        in user encoding.
586
 
        """
587
 
        self.requireFeature(tests.UnicodeFilenameFeature)
588
 
        # The word 'test' in Russian
589
 
        _russian_test = u'\u0422\u0435\u0441\u0442'
590
 
        directory = _russian_test + u'/'
591
 
        test_txt = _russian_test + u'.txt'
592
 
        u1234 = u'\u1234.txt'
593
 
 
594
 
        tree = self.make_branch_and_tree('.')
595
 
        self.build_tree_contents([
596
 
            (test_txt, 'foo\n'),
597
 
            (u1234, 'foo\n'),
598
 
            (directory, None),
599
 
            ])
600
 
        tree.add([test_txt, u1234, directory])
601
 
 
602
 
        sio = StringIO()
603
 
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
604
 
            path_encoding='cp1251')
605
 
 
606
 
        output = subst_dates(sio.getvalue())
607
 
        shouldbe = ('''\
608
 
=== added directory '%(directory)s'
609
 
=== added file '%(test_txt)s'
610
 
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
611
 
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
612
 
@@ -0,0 +1,1 @@
613
 
+foo
614
 
 
615
 
=== added file '?.txt'
616
 
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
617
 
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
618
 
@@ -0,0 +1,1 @@
619
 
+foo
620
 
 
621
 
''' % {'directory': _russian_test.encode('cp1251'),
622
 
       'test_txt': test_txt.encode('cp1251'),
623
 
      })
624
 
        self.assertEqualDiff(output, shouldbe)
625
 
 
626
 
 
627
 
class DiffWasIs(diff.DiffPath):
 
584
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
585
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
586
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
587
 
 
588
 
 
589
class DiffWasIs(DiffPath):
628
590
 
629
591
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
630
592
        self.to_file.write('was: ')
634
596
        pass
635
597
 
636
598
 
637
 
class TestDiffTree(tests.TestCaseWithTransport):
 
599
class TestDiffTree(TestCaseWithTransport):
638
600
 
639
601
    def setUp(self):
640
 
        super(TestDiffTree, self).setUp()
 
602
        TestCaseWithTransport.setUp(self)
641
603
        self.old_tree = self.make_branch_and_tree('old-tree')
642
604
        self.old_tree.lock_write()
643
605
        self.addCleanup(self.old_tree.unlock)
644
606
        self.new_tree = self.make_branch_and_tree('new-tree')
645
607
        self.new_tree.lock_write()
646
608
        self.addCleanup(self.new_tree.unlock)
647
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
609
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
648
610
 
649
611
    def test_diff_text(self):
650
612
        self.build_tree_contents([('old-tree/olddir/',),
655
617
                                  ('new-tree/newdir/newfile', 'new\n')])
656
618
        self.new_tree.add('newdir')
657
619
        self.new_tree.add('newdir/newfile', 'file-id')
658
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
620
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
659
621
        differ.diff_text('file-id', None, 'old label', 'new label')
660
622
        self.assertEqual(
661
623
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
690
652
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
691
653
 
692
654
    def test_diff_symlink(self):
693
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
655
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
694
656
        differ.diff_symlink('old target', None)
695
657
        self.assertEqual("=== target was 'old target'\n",
696
658
                         differ.to_file.getvalue())
697
659
 
698
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
660
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
699
661
        differ.diff_symlink(None, 'new target')
700
662
        self.assertEqual("=== target is 'new target'\n",
701
663
                         differ.to_file.getvalue())
702
664
 
703
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
665
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
704
666
        differ.diff_symlink('old target', 'new target')
705
667
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
706
668
                         differ.to_file.getvalue())
756
718
 
757
719
    def test_register_diff(self):
758
720
        self.create_old_new()
759
 
        old_diff_factories = diff.DiffTree.diff_factories
760
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
761
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
721
        old_diff_factories = DiffTree.diff_factories
 
722
        DiffTree.diff_factories=old_diff_factories[:]
 
723
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
762
724
        try:
763
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
725
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
764
726
        finally:
765
 
            diff.DiffTree.diff_factories = old_diff_factories
 
727
            DiffTree.diff_factories = old_diff_factories
766
728
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
767
729
        self.assertNotContainsRe(
768
730
            differ.to_file.getvalue(),
773
735
 
774
736
    def test_extra_factories(self):
775
737
        self.create_old_new()
776
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
777
 
                               extra_factories=[DiffWasIs.from_diff_tree])
 
738
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
739
                            extra_factories=[DiffWasIs.from_diff_tree])
778
740
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
779
741
        self.assertNotContainsRe(
780
742
            differ.to_file.getvalue(),
793
755
            '.*a-file(.|\n)*b-file')
794
756
 
795
757
 
796
 
class TestPatienceDiffLib(tests.TestCase):
 
758
class TestPatienceDiffLib(TestCase):
797
759
 
798
760
    def setUp(self):
799
761
        super(TestPatienceDiffLib, self).setUp()
800
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
801
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
762
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
763
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
802
764
        self._PatienceSequenceMatcher = \
803
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
765
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
804
766
 
805
767
    def test_diff_unicode_string(self):
806
768
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
1113
1075
                 'how are you today?\n']
1114
1076
        txt_b = ['hello there\n',
1115
1077
                 'how are you today?\n']
1116
 
        unified_diff = patiencediff.unified_diff
 
1078
        unified_diff = bzrlib.patiencediff.unified_diff
1117
1079
        psm = self._PatienceSequenceMatcher
1118
1080
        self.assertEquals(['--- \n',
1119
1081
                           '+++ \n',
1167
1129
                 'how are you today?\n']
1168
1130
        txt_b = ['hello there\n',
1169
1131
                 'how are you today?\n']
1170
 
        unified_diff = patiencediff.unified_diff
 
1132
        unified_diff = bzrlib.patiencediff.unified_diff
1171
1133
        psm = self._PatienceSequenceMatcher
1172
1134
        self.assertEquals(['--- a\t2008-08-08\n',
1173
1135
                           '+++ b\t2008-09-09\n',
1189
1151
 
1190
1152
    def setUp(self):
1191
1153
        super(TestPatienceDiffLib_c, self).setUp()
1192
 
        from bzrlib import _patiencediff_c
1193
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1194
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1154
        import bzrlib._patiencediff_c
 
1155
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1156
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1195
1157
        self._PatienceSequenceMatcher = \
1196
 
            _patiencediff_c.PatienceSequenceMatcher_c
 
1158
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1197
1159
 
1198
1160
    def test_unhashable(self):
1199
1161
        """We should get a proper exception here."""
1209
1171
                                         None, ['valid'], ['valid', []])
1210
1172
 
1211
1173
 
1212
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1174
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1213
1175
 
1214
1176
    def setUp(self):
1215
1177
        super(TestPatienceDiffLibFiles, self).setUp()
1216
1178
        self._PatienceSequenceMatcher = \
1217
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
1179
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1218
1180
 
1219
1181
    def test_patience_unified_diff_files(self):
1220
1182
        txt_a = ['hello there\n',
1225
1187
        open('a1', 'wb').writelines(txt_a)
1226
1188
        open('b1', 'wb').writelines(txt_b)
1227
1189
 
1228
 
        unified_diff_files = patiencediff.unified_diff_files
 
1190
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1229
1191
        psm = self._PatienceSequenceMatcher
1230
1192
        self.assertEquals(['--- a1\n',
1231
1193
                           '+++ b1\n',
1285
1247
 
1286
1248
    def setUp(self):
1287
1249
        super(TestPatienceDiffLibFiles_c, self).setUp()
1288
 
        from bzrlib import _patiencediff_c
 
1250
        import bzrlib._patiencediff_c
1289
1251
        self._PatienceSequenceMatcher = \
1290
 
            _patiencediff_c.PatienceSequenceMatcher_c
1291
 
 
1292
 
 
1293
 
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1252
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1253
 
 
1254
 
 
1255
class TestUsingCompiledIfAvailable(TestCase):
1294
1256
 
1295
1257
    def test_PatienceSequenceMatcher(self):
1296
1258
        if compiled_patiencediff_feature.available():
1297
1259
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1298
1260
            self.assertIs(PatienceSequenceMatcher_c,
1299
 
                          patiencediff.PatienceSequenceMatcher)
 
1261
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1300
1262
        else:
1301
1263
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1302
1264
            self.assertIs(PatienceSequenceMatcher_py,
1303
 
                          patiencediff.PatienceSequenceMatcher)
 
1265
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1304
1266
 
1305
1267
    def test_unique_lcs(self):
1306
1268
        if compiled_patiencediff_feature.available():
1307
1269
            from bzrlib._patiencediff_c import unique_lcs_c
1308
1270
            self.assertIs(unique_lcs_c,
1309
 
                          patiencediff.unique_lcs)
 
1271
                          bzrlib.patiencediff.unique_lcs)
1310
1272
        else:
1311
1273
            from bzrlib._patiencediff_py import unique_lcs_py
1312
1274
            self.assertIs(unique_lcs_py,
1313
 
                          patiencediff.unique_lcs)
 
1275
                          bzrlib.patiencediff.unique_lcs)
1314
1276
 
1315
1277
    def test_recurse_matches(self):
1316
1278
        if compiled_patiencediff_feature.available():
1317
1279
            from bzrlib._patiencediff_c import recurse_matches_c
1318
1280
            self.assertIs(recurse_matches_c,
1319
 
                          patiencediff.recurse_matches)
 
1281
                          bzrlib.patiencediff.recurse_matches)
1320
1282
        else:
1321
1283
            from bzrlib._patiencediff_py import recurse_matches_py
1322
1284
            self.assertIs(recurse_matches_py,
1323
 
                          patiencediff.recurse_matches)
1324
 
 
1325
 
 
1326
 
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1285
                          bzrlib.patiencediff.recurse_matches)
 
1286
 
 
1287
 
 
1288
class TestDiffFromTool(TestCaseWithTransport):
1327
1289
 
1328
1290
    def test_from_string(self):
1329
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1291
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1330
1292
        self.addCleanup(diff_obj.finish)
1331
1293
        self.assertEqual(['diff', '@old_path', '@new_path'],
1332
1294
            diff_obj.command_template)
1333
1295
 
1334
1296
    def test_from_string_u5(self):
1335
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1336
 
                                                 None, None, None)
 
1297
        diff_obj = DiffFromTool.from_string('diff "-u 5"', None, None, None)
1337
1298
        self.addCleanup(diff_obj.finish)
1338
1299
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1339
1300
                         diff_obj.command_template)
1340
1301
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1341
1302
                         diff_obj._get_command('old-path', 'new-path'))
1342
 
 
 
1303
        
1343
1304
    def test_from_string_path_with_backslashes(self):
1344
 
        self.requireFeature(features.backslashdir_feature)
 
1305
        self.requireFeature(BackslashDirSeparatorFeature)
1345
1306
        tool = 'C:\\Tools\\Diff.exe'
1346
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
 
1307
        diff_obj = DiffFromTool.from_string(tool, None, None, None)
1347
1308
        self.addCleanup(diff_obj.finish)
1348
1309
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1349
1310
                         diff_obj.command_template)
1352
1313
 
1353
1314
    def test_execute(self):
1354
1315
        output = StringIO()
1355
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1356
 
                                      'print "@old_path @new_path"'],
1357
 
                                     None, None, output)
 
1316
        diff_obj = DiffFromTool(['python', '-c',
 
1317
                                 'print "@old_path @new_path"'],
 
1318
                                None, None, output)
1358
1319
        self.addCleanup(diff_obj.finish)
1359
1320
        diff_obj._execute('old', 'new')
1360
1321
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1361
1322
 
1362
1323
    def test_excute_missing(self):
1363
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1364
 
                                     None, None, None)
 
1324
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1325
                                None, None, None)
1365
1326
        self.addCleanup(diff_obj.finish)
1366
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1367
 
                              'old', 'new')
 
1327
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1328
                              'new')
1368
1329
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1369
1330
                         ' on this machine', str(e))
1370
1331
 
1380
1341
        basis_tree = tree.basis_tree()
1381
1342
        basis_tree.lock_read()
1382
1343
        self.addCleanup(basis_tree.unlock)
1383
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1384
 
                                      'print "@old_path @new_path"'],
1385
 
                                     basis_tree, tree, output)
 
1344
        diff_obj = DiffFromTool(['python', '-c',
 
1345
                                 'print "@old_path @new_path"'],
 
1346
                                basis_tree, tree, output)
1386
1347
        diff_obj._prepare_files('file-id', 'file', 'file')
1387
1348
        # The old content should be readonly
1388
1349
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1405
1366
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1406
1367
        tree.add('oldname', 'file-id')
1407
1368
        tree.add('oldname2', 'file2-id')
1408
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1409
 
        tree.commit('old tree', timestamp=315532800)
 
1369
        tree.commit('old tree', timestamp=0)
1410
1370
        tree.rename_one('oldname', 'newname')
1411
1371
        tree.rename_one('oldname2', 'newname2')
1412
1372
        self.build_tree_contents([('tree/newname', 'newcontent')])
1416
1376
        self.addCleanup(old_tree.unlock)
1417
1377
        tree.lock_read()
1418
1378
        self.addCleanup(tree.unlock)
1419
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1420
 
                                      'print "@old_path @new_path"'],
1421
 
                                     old_tree, tree, output)
 
1379
        diff_obj = DiffFromTool(['python', '-c',
 
1380
                                 'print "@old_path @new_path"'],
 
1381
                                old_tree, tree, output)
1422
1382
        self.addCleanup(diff_obj.finish)
1423
1383
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1424
1384
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1425
1385
                                                     'newname')
1426
1386
        self.assertContainsRe(old_path, 'old/oldname$')
1427
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
 
1387
        self.assertEqual(0, os.stat(old_path).st_mtime)
1428
1388
        self.assertContainsRe(new_path, 'tree/newname$')
1429
1389
        self.assertFileEqual('oldcontent', old_path)
1430
1390
        self.assertFileEqual('newcontent', new_path)
1434
1394
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1435
1395
 
1436
1396
 
1437
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1438
 
 
1439
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1440
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1441
 
        TestGetTreesAndBranchesToDiff.
1442
 
        """
1443
 
        return diff.get_trees_and_branches_to_diff_locked(
1444
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
 
1397
class TestGetTreesAndBranchesToDiff(TestCaseWithTransport):
1445
1398
 
1446
1399
    def test_basic(self):
1447
1400
        tree = self.make_branch_and_tree('tree')
1448
1401
        (old_tree, new_tree,
1449
1402
         old_branch, new_branch,
1450
 
         specific_files, extra_trees) = self.call_gtabtd(
1451
 
             ['tree'], None, None, None)
 
1403
         specific_files, extra_trees) = \
 
1404
            get_trees_and_branches_to_diff(['tree'], None, None, None)
1452
1405
 
1453
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1454
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1455
 
                         old_tree.get_revision_id())
 
1406
        self.assertIsInstance(old_tree, RevisionTree)
 
1407
        #print dir (old_tree)
 
1408
        self.assertEqual(_mod_revision.NULL_REVISION, old_tree.get_revision_id())
1456
1409
        self.assertEqual(tree.basedir, new_tree.basedir)
1457
1410
        self.assertEqual(tree.branch.base, old_branch.base)
1458
1411
        self.assertEqual(tree.branch.base, new_branch.base)
1467
1420
        self.build_tree_contents([('tree/file', 'newcontent')])
1468
1421
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1469
1422
 
1470
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1471
 
                     revisionspec.RevisionSpec.from_string('2')]
 
1423
        revisions = [RevisionSpec.from_string('1'),
 
1424
                     RevisionSpec.from_string('2')]
1472
1425
        (old_tree, new_tree,
1473
1426
         old_branch, new_branch,
1474
 
         specific_files, extra_trees) = self.call_gtabtd(
1475
 
            ['tree'], revisions, None, None)
 
1427
         specific_files, extra_trees) = \
 
1428
            get_trees_and_branches_to_diff(['tree'], revisions, None, None)
1476
1429
 
1477
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1430
        self.assertIsInstance(old_tree, RevisionTree)
1478
1431
        self.assertEqual("old-id", old_tree.get_revision_id())
1479
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
 
1432
        self.assertIsInstance(new_tree, RevisionTree)
1480
1433
        self.assertEqual("new-id", new_tree.get_revision_id())
1481
1434
        self.assertEqual(tree.branch.base, old_branch.base)
1482
1435
        self.assertEqual(tree.branch.base, new_branch.base)
1483
1436
        self.assertIs(None, specific_files)
1484
1437
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1485
 
 
1486
 
 
1487
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1488
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1489
 
    deprecated get_trees_and_branches_to_diff function.
1490
 
    """
1491
 
 
1492
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1493
 
        return self.applyDeprecated(
1494
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1495
 
            path_list, revision_specs, old_url, new_url)
1496