← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

  • Committer: Aaron Bentley
  • Date: 2010-01-20 07:27:49 UTC
  • mto: This revision was merged to the branch mainline in revision 5049.
  • Revision ID: aaron@aaronbentley.com-20100120072749-kb2r2shencwhekkd
It makes more sense to get the dev focus from an existing Launchpad branch
object, especially given that you need a Launchpad branch object to get it.

Show diffs side-by-side

added added

removed removed

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