← 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 Pool
  • Date: 2010-04-21 11:27:04 UTC
  • mto: This revision was merged to the branch mainline in revision 5189.
  • Revision ID: mbp@canonical.com-20100421112704-zijso22b6pdevrxy
Simplify various code to use user_url

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