← 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: 2006-06-09 07:45:35 UTC
  • mto: (1755.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 1756.
  • Revision ID: robertc@robertcollins.net-20060609074535-3002a0209179b35c
Fixup '== None' usage in inventory.py.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Development 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
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import os
18
18
from cStringIO import StringIO
19
 
import subprocess
20
 
import sys
21
 
import tempfile
22
 
 
23
 
from bzrlib import (
24
 
    diff,
25
 
    errors,
26
 
    osutils,
27
 
    patiencediff,
28
 
    _patiencediff_py,
29
 
    revision as _mod_revision,
30
 
    revisionspec,
31
 
    revisiontree,
32
 
    tests,
33
 
    transform,
34
 
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features
37
 
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
 
39
 
 
40
 
class _AttribFeature(tests.Feature):
41
 
 
42
 
    def _probe(self):
43
 
        if (sys.platform not in ('cygwin', 'win32')):
44
 
            return False
45
 
        try:
46
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
47
 
        except OSError, e:
48
 
            return False
49
 
        return (0 == proc.wait())
50
 
 
51
 
    def feature_name(self):
52
 
        return 'attrib Windows command-line tool'
53
 
 
54
 
AttribFeature = _AttribFeature()
55
 
 
56
 
 
57
 
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
58
 
                                    'bzrlib._patiencediff_c')
 
19
 
 
20
from bzrlib.diff import internal_diff, show_diff_trees
 
21
from bzrlib.errors import BinaryFile
 
22
import bzrlib.patiencediff
 
23
from bzrlib.tests import TestCase, TestCaseWithTransport, TestCaseInTempDir
 
24
from bzrlib.tests import TestCase, TestCaseInTempDir
59
25
 
60
26
 
61
27
def udiff_lines(old, new, allow_binary=False):
62
28
    output = StringIO()
63
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
29
    internal_diff('old', old, 'new', new, output, allow_binary)
64
30
    output.seek(0, 0)
65
31
    return output.readlines()
66
32
 
67
33
 
68
 
def external_udiff_lines(old, new, use_stringio=False):
69
 
    if use_stringio:
70
 
        # StringIO has no fileno, so it tests a different codepath
71
 
        output = StringIO()
72
 
    else:
73
 
        output = tempfile.TemporaryFile()
74
 
    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')
78
 
    output.seek(0, 0)
79
 
    lines = output.readlines()
80
 
    output.close()
81
 
    return lines
82
 
 
83
 
 
84
 
class TestDiff(tests.TestCase):
 
34
class TestDiff(TestCase):
85
35
 
86
36
    def test_add_nl(self):
87
37
        """diff generates a valid diff for patches that add a newline"""
123
73
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
124
74
 
125
75
    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)
132
 
 
133
 
    def test_external_diff(self):
134
 
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
135
 
        self.check_patch(lines)
136
 
        self.assertEqual('\n', lines[-1])
137
 
 
138
 
    def test_external_diff_no_fileno(self):
139
 
        # Make sure that we can handle not having a fileno, even
140
 
        # if the diff is large
141
 
        lines = external_udiff_lines(['boo\n']*10000,
142
 
                                     ['goo\n']*10000,
143
 
                                     use_stringio=True)
144
 
        self.check_patch(lines)
145
 
 
146
 
    def test_external_diff_binary_lang_c(self):
147
 
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
148
 
            self.overrideEnv(lang, 'C')
149
 
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
150
 
        # Older versions of diffutils say "Binary files", newer
151
 
        # versions just say "Files".
152
 
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
153
 
        self.assertEquals(lines[1:], ['\n'])
154
 
 
155
 
    def test_no_external_diff(self):
156
 
        """Check that NoDiff is raised when diff is not available"""
157
 
        # Make sure no 'diff' command is available
158
 
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
159
 
        self.overrideEnv('PATH', '')
160
 
        self.assertRaises(errors.NoDiff, diff.external_diff,
161
 
                          'old', ['boo\n'], 'new', ['goo\n'],
162
 
                          StringIO(), diff_opts=['-u'])
 
76
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
77
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
78
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
79
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
163
80
 
164
81
    def test_internal_diff_default(self):
165
82
        # Default internal diff encoding is utf8
166
83
        output = StringIO()
167
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
168
 
                           u'new_\xe5', ['new_text\n'], output)
 
84
        internal_diff(u'old_\xb5', ['old_text\n'],
 
85
                    u'new_\xe5', ['new_text\n'], output)
169
86
        lines = output.getvalue().splitlines(True)
170
87
        self.check_patch(lines)
171
88
        self.assertEquals(['--- old_\xc2\xb5\n',
179
96
 
180
97
    def test_internal_diff_utf8(self):
181
98
        output = StringIO()
182
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
183
 
                           u'new_\xe5', ['new_text\n'], output,
184
 
                           path_encoding='utf8')
 
99
        internal_diff(u'old_\xb5', ['old_text\n'],
 
100
                    u'new_\xe5', ['new_text\n'], output,
 
101
                    path_encoding='utf8')
185
102
        lines = output.getvalue().splitlines(True)
186
103
        self.check_patch(lines)
187
104
        self.assertEquals(['--- old_\xc2\xb5\n',
195
112
 
196
113
    def test_internal_diff_iso_8859_1(self):
197
114
        output = StringIO()
198
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
199
 
                           u'new_\xe5', ['new_text\n'], output,
200
 
                           path_encoding='iso-8859-1')
 
115
        internal_diff(u'old_\xb5', ['old_text\n'],
 
116
                    u'new_\xe5', ['new_text\n'], output,
 
117
                    path_encoding='iso-8859-1')
201
118
        lines = output.getvalue().splitlines(True)
202
119
        self.check_patch(lines)
203
120
        self.assertEquals(['--- old_\xb5\n',
209
126
                          ]
210
127
                          , lines)
211
128
 
212
 
    def test_internal_diff_no_content(self):
213
 
        output = StringIO()
214
 
        diff.internal_diff(u'old', [], u'new', [], output)
215
 
        self.assertEqual('', output.getvalue())
216
 
 
217
 
    def test_internal_diff_no_changes(self):
218
 
        output = StringIO()
219
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
220
 
                           u'new', ['text\n', 'contents\n'],
221
 
                           output)
222
 
        self.assertEqual('', output.getvalue())
223
 
 
224
129
    def test_internal_diff_returns_bytes(self):
225
130
        import StringIO
226
131
        output = StringIO.StringIO()
227
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
228
 
                            u'new_\xe5', ['new_text\n'], output)
229
 
        self.assertIsInstance(output.getvalue(), str,
 
132
        internal_diff(u'old_\xb5', ['old_text\n'],
 
133
                    u'new_\xe5', ['new_text\n'], output)
 
134
        self.failUnless(isinstance(output.getvalue(), str),
230
135
            'internal_diff should return bytestrings')
231
136
 
232
137
 
233
 
class TestDiffFiles(tests.TestCaseInTempDir):
234
 
 
235
 
    def test_external_diff_binary(self):
236
 
        """The output when using external diff should use diff's i18n error"""
237
 
        # Make sure external_diff doesn't fail in the current LANG
238
 
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
239
 
 
240
 
        cmd = ['diff', '-u', '--binary', 'old', 'new']
241
 
        open('old', 'wb').write('\x00foobar\n')
242
 
        open('new', 'wb').write('foo\x00bar\n')
243
 
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
244
 
                                     stdin=subprocess.PIPE)
245
 
        out, err = pipe.communicate()
246
 
        # Diff returns '2' on Binary files.
247
 
        self.assertEqual(2, pipe.returncode)
248
 
        # We should output whatever diff tells us, plus a trailing newline
249
 
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
250
 
 
251
 
 
252
 
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
253
 
    output = StringIO()
254
 
    if working_tree is not None:
255
 
        extra_trees = (working_tree,)
256
 
    else:
257
 
        extra_trees = ()
258
 
    diff.show_diff_trees(tree1, tree2, output,
259
 
        specific_files=specific_files,
260
 
        extra_trees=extra_trees, old_label='old/',
261
 
        new_label='new/')
262
 
    return output.getvalue()
263
 
 
264
 
 
265
 
class TestDiffDates(tests.TestCaseWithTransport):
 
138
class TestDiffDates(TestCaseWithTransport):
266
139
 
267
140
    def setUp(self):
268
141
        super(TestDiffDates, self).setUp()
302
175
        # set the date stamps for files in the working tree to known values
303
176
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
304
177
 
 
178
    def get_diff(self, tree1, tree2):
 
179
        output = StringIO()
 
180
        show_diff_trees(tree1, tree2, output,
 
181
                        old_label='old/', new_label='new/')
 
182
        return output.getvalue()
 
183
 
305
184
    def test_diff_rev_tree_working_tree(self):
306
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
185
        output = self.get_diff(self.wt.basis_tree(), self.wt)
307
186
        # note that the date for old/file1 is from rev 2 rather than from
308
187
        # the basis revision (rev 4)
309
188
        self.assertEqualDiff(output, '''\
319
198
    def test_diff_rev_tree_rev_tree(self):
320
199
        tree1 = self.b.repository.revision_tree('rev-2')
321
200
        tree2 = self.b.repository.revision_tree('rev-3')
322
 
        output = get_diff_as_string(tree1, tree2)
 
201
        output = self.get_diff(tree1, tree2)
323
202
        self.assertEqualDiff(output, '''\
324
203
=== modified file 'file2'
325
204
--- old/file2\t2006-04-01 00:00:00 +0000
329
208
+file2 contents at rev 3
330
209
 
331
210
''')
332
 
 
 
211
        
333
212
    def test_diff_add_files(self):
334
 
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
 
213
        tree1 = self.b.repository.revision_tree(None)
335
214
        tree2 = self.b.repository.revision_tree('rev-1')
336
 
        output = get_diff_as_string(tree1, tree2)
 
215
        output = self.get_diff(tree1, tree2)
337
216
        # the files have the epoch time stamp for the tree in which
338
217
        # they don't exist.
339
218
        self.assertEqualDiff(output, '''\
354
233
    def test_diff_remove_files(self):
355
234
        tree1 = self.b.repository.revision_tree('rev-3')
356
235
        tree2 = self.b.repository.revision_tree('rev-4')
357
 
        output = get_diff_as_string(tree1, tree2)
 
236
        output = self.get_diff(tree1, tree2)
358
237
        # the file has the epoch time stamp for the tree in which
359
238
        # it doesn't exist.
360
239
        self.assertEqualDiff(output, '''\
366
245
 
367
246
''')
368
247
 
369
 
    def test_show_diff_specified(self):
370
 
        """A working tree filename can be used to identify a file"""
371
 
        self.wt.rename_one('file1', 'file1b')
372
 
        old_tree = self.b.repository.revision_tree('rev-1')
373
 
        new_tree = self.b.repository.revision_tree('rev-4')
374
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
375
 
                            working_tree=self.wt)
376
 
        self.assertContainsRe(out, 'file1\t')
377
 
 
378
 
    def test_recursive_diff(self):
379
 
        """Children of directories are matched"""
380
 
        os.mkdir('dir1')
381
 
        os.mkdir('dir2')
382
 
        self.wt.add(['dir1', 'dir2'])
383
 
        self.wt.rename_one('file1', 'dir1/file1')
384
 
        old_tree = self.b.repository.revision_tree('rev-1')
385
 
        new_tree = self.b.repository.revision_tree('rev-4')
386
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
387
 
                            working_tree=self.wt)
388
 
        self.assertContainsRe(out, 'file1\t')
389
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
390
 
                            working_tree=self.wt)
391
 
        self.assertNotContainsRe(out, 'file1\t')
392
 
 
393
 
 
394
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
395
 
    """Direct tests for show_diff_trees"""
396
 
 
397
 
    def test_modified_file(self):
398
 
        """Test when a file is modified."""
399
 
        tree = self.make_branch_and_tree('tree')
400
 
        self.build_tree_contents([('tree/file', 'contents\n')])
401
 
        tree.add(['file'], ['file-id'])
402
 
        tree.commit('one', rev_id='rev-1')
403
 
 
404
 
        self.build_tree_contents([('tree/file', 'new contents\n')])
405
 
        d = get_diff_as_string(tree.basis_tree(), tree)
406
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
407
 
        self.assertContainsRe(d, '--- old/file\t')
408
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
409
 
        self.assertContainsRe(d, '-contents\n'
410
 
                                 '\\+new contents\n')
411
 
 
412
 
    def test_modified_file_in_renamed_dir(self):
413
 
        """Test when a file is modified in a renamed directory."""
414
 
        tree = self.make_branch_and_tree('tree')
415
 
        self.build_tree(['tree/dir/'])
416
 
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
417
 
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
418
 
        tree.commit('one', rev_id='rev-1')
419
 
 
420
 
        tree.rename_one('dir', 'other')
421
 
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
422
 
        d = get_diff_as_string(tree.basis_tree(), tree)
423
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
424
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
425
 
        # XXX: This is technically incorrect, because it used to be at another
426
 
        # location. What to do?
427
 
        self.assertContainsRe(d, '--- old/dir/file\t')
428
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
429
 
        self.assertContainsRe(d, '-contents\n'
430
 
                                 '\\+new contents\n')
431
 
 
432
 
    def test_renamed_directory(self):
433
 
        """Test when only a directory is only renamed."""
434
 
        tree = self.make_branch_and_tree('tree')
435
 
        self.build_tree(['tree/dir/'])
436
 
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
437
 
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
438
 
        tree.commit('one', rev_id='rev-1')
439
 
 
440
 
        tree.rename_one('dir', 'newdir')
441
 
        d = get_diff_as_string(tree.basis_tree(), tree)
442
 
        # Renaming a directory should be a single "you renamed this dir" even
443
 
        # when there are files inside.
444
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
445
 
 
446
 
    def test_renamed_file(self):
447
 
        """Test when a file is only renamed."""
448
 
        tree = self.make_branch_and_tree('tree')
449
 
        self.build_tree_contents([('tree/file', 'contents\n')])
450
 
        tree.add(['file'], ['file-id'])
451
 
        tree.commit('one', rev_id='rev-1')
452
 
 
453
 
        tree.rename_one('file', 'newname')
454
 
        d = get_diff_as_string(tree.basis_tree(), tree)
455
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
456
 
        # We shouldn't have a --- or +++ line, because there is no content
457
 
        # change
458
 
        self.assertNotContainsRe(d, '---')
459
 
 
460
 
    def test_renamed_and_modified_file(self):
461
 
        """Test when a file is only renamed."""
462
 
        tree = self.make_branch_and_tree('tree')
463
 
        self.build_tree_contents([('tree/file', 'contents\n')])
464
 
        tree.add(['file'], ['file-id'])
465
 
        tree.commit('one', rev_id='rev-1')
466
 
 
467
 
        tree.rename_one('file', 'newname')
468
 
        self.build_tree_contents([('tree/newname', 'new contents\n')])
469
 
        d = get_diff_as_string(tree.basis_tree(), tree)
470
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
471
 
        self.assertContainsRe(d, '--- old/file\t')
472
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
473
 
        self.assertContainsRe(d, '-contents\n'
474
 
                                 '\\+new contents\n')
475
 
 
476
 
 
477
 
    def test_internal_diff_exec_property(self):
478
 
        tree = self.make_branch_and_tree('tree')
479
 
 
480
 
        tt = transform.TreeTransform(tree)
481
 
        tt.new_file('a', tt.root, 'contents\n', 'a-id', True)
482
 
        tt.new_file('b', tt.root, 'contents\n', 'b-id', False)
483
 
        tt.new_file('c', tt.root, 'contents\n', 'c-id', True)
484
 
        tt.new_file('d', tt.root, 'contents\n', 'd-id', False)
485
 
        tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)
486
 
        tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)
487
 
        tt.apply()
488
 
        tree.commit('one', rev_id='rev-1')
489
 
 
490
 
        tt = transform.TreeTransform(tree)
491
 
        tt.set_executability(False, tt.trans_id_file_id('a-id'))
492
 
        tt.set_executability(True, tt.trans_id_file_id('b-id'))
493
 
        tt.set_executability(False, tt.trans_id_file_id('c-id'))
494
 
        tt.set_executability(True, tt.trans_id_file_id('d-id'))
495
 
        tt.apply()
496
 
        tree.rename_one('c', 'new-c')
497
 
        tree.rename_one('d', 'new-d')
498
 
 
499
 
        d = get_diff_as_string(tree.basis_tree(), tree)
500
 
 
501
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
502
 
                                  ".*\+x to -x.*\)")
503
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
504
 
                                  ".*-x to \+x.*\)")
505
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
506
 
                                  ".*\+x to -x.*\)")
507
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
508
 
                                  ".*-x to \+x.*\)")
509
 
        self.assertNotContainsRe(d, r"file 'e'")
510
 
        self.assertNotContainsRe(d, r"file 'f'")
511
 
 
512
 
    def test_binary_unicode_filenames(self):
513
 
        """Test that contents of files are *not* encoded in UTF-8 when there
514
 
        is a binary file in the diff.
515
 
        """
516
 
        # See https://bugs.launchpad.net/bugs/110092.
517
 
        self.requireFeature(tests.UnicodeFilenameFeature)
518
 
 
519
 
        # This bug isn't triggered with cStringIO.
520
 
        from StringIO import StringIO
521
 
        tree = self.make_branch_and_tree('tree')
522
 
        alpha, omega = u'\u03b1', u'\u03c9'
523
 
        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')
524
 
        self.build_tree_contents(
525
 
            [('tree/' + alpha, chr(0)),
526
 
             ('tree/' + omega,
527
 
              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])
528
 
        tree.add([alpha], ['file-id'])
529
 
        tree.add([omega], ['file-id-2'])
530
 
        diff_content = StringIO()
531
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
532
 
        d = diff_content.getvalue()
533
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
534
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
535
 
                              % (alpha_utf8, alpha_utf8))
536
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
537
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
538
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
539
 
 
540
 
    def test_unicode_filename(self):
541
 
        """Test when the filename are unicode."""
542
 
        self.requireFeature(tests.UnicodeFilenameFeature)
543
 
 
544
 
        alpha, omega = u'\u03b1', u'\u03c9'
545
 
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
546
 
 
547
 
        tree = self.make_branch_and_tree('tree')
548
 
        self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])
549
 
        tree.add(['ren_'+alpha], ['file-id-2'])
550
 
        self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])
551
 
        tree.add(['del_'+alpha], ['file-id-3'])
552
 
        self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])
553
 
        tree.add(['mod_'+alpha], ['file-id-4'])
554
 
 
555
 
        tree.commit('one', rev_id='rev-1')
556
 
 
557
 
        tree.rename_one('ren_'+alpha, 'ren_'+omega)
558
 
        tree.remove('del_'+alpha)
559
 
        self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])
560
 
        tree.add(['add_'+alpha], ['file-id'])
561
 
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
562
 
 
563
 
        d = get_diff_as_string(tree.basis_tree(), tree)
564
 
        self.assertContainsRe(d,
565
 
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
566
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
567
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
568
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
569
 
 
570
 
    def test_unicode_filename_path_encoding(self):
571
 
        """Test for bug #382699: unicode filenames on Windows should be shown
572
 
        in user encoding.
573
 
        """
574
 
        self.requireFeature(tests.UnicodeFilenameFeature)
575
 
        # The word 'test' in Russian
576
 
        _russian_test = u'\u0422\u0435\u0441\u0442'
577
 
        directory = _russian_test + u'/'
578
 
        test_txt = _russian_test + u'.txt'
579
 
        u1234 = u'\u1234.txt'
580
 
 
581
 
        tree = self.make_branch_and_tree('.')
582
 
        self.build_tree_contents([
583
 
            (test_txt, 'foo\n'),
584
 
            (u1234, 'foo\n'),
585
 
            (directory, None),
586
 
            ])
587
 
        tree.add([test_txt, u1234, directory])
588
 
 
589
 
        sio = StringIO()
590
 
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
591
 
            path_encoding='cp1251')
592
 
 
593
 
        output = subst_dates(sio.getvalue())
594
 
        shouldbe = ('''\
595
 
=== added directory '%(directory)s'
596
 
=== added file '%(test_txt)s'
597
 
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
598
 
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
599
 
@@ -0,0 +1,1 @@
600
 
+foo
601
 
 
602
 
=== added file '?.txt'
603
 
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
604
 
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
605
 
@@ -0,0 +1,1 @@
606
 
+foo
607
 
 
608
 
''' % {'directory': _russian_test.encode('cp1251'),
609
 
       'test_txt': test_txt.encode('cp1251'),
610
 
      })
611
 
        self.assertEqualDiff(output, shouldbe)
612
 
 
613
 
 
614
 
class DiffWasIs(diff.DiffPath):
615
 
 
616
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
617
 
        self.to_file.write('was: ')
618
 
        self.to_file.write(self.old_tree.get_file(file_id).read())
619
 
        self.to_file.write('is: ')
620
 
        self.to_file.write(self.new_tree.get_file(file_id).read())
621
 
        pass
622
 
 
623
 
 
624
 
class TestDiffTree(tests.TestCaseWithTransport):
625
 
 
626
 
    def setUp(self):
627
 
        super(TestDiffTree, self).setUp()
628
 
        self.old_tree = self.make_branch_and_tree('old-tree')
629
 
        self.old_tree.lock_write()
630
 
        self.addCleanup(self.old_tree.unlock)
631
 
        self.new_tree = self.make_branch_and_tree('new-tree')
632
 
        self.new_tree.lock_write()
633
 
        self.addCleanup(self.new_tree.unlock)
634
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
635
 
 
636
 
    def test_diff_text(self):
637
 
        self.build_tree_contents([('old-tree/olddir/',),
638
 
                                  ('old-tree/olddir/oldfile', 'old\n')])
639
 
        self.old_tree.add('olddir')
640
 
        self.old_tree.add('olddir/oldfile', 'file-id')
641
 
        self.build_tree_contents([('new-tree/newdir/',),
642
 
                                  ('new-tree/newdir/newfile', 'new\n')])
643
 
        self.new_tree.add('newdir')
644
 
        self.new_tree.add('newdir/newfile', 'file-id')
645
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
646
 
        differ.diff_text('file-id', None, 'old label', 'new label')
647
 
        self.assertEqual(
648
 
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
649
 
            differ.to_file.getvalue())
650
 
        differ.to_file.seek(0)
651
 
        differ.diff_text(None, 'file-id', 'old label', 'new label')
652
 
        self.assertEqual(
653
 
            '--- old label\n+++ new label\n@@ -0,0 +1,1 @@\n+new\n\n',
654
 
            differ.to_file.getvalue())
655
 
        differ.to_file.seek(0)
656
 
        differ.diff_text('file-id', 'file-id', 'old label', 'new label')
657
 
        self.assertEqual(
658
 
            '--- old label\n+++ new label\n@@ -1,1 +1,1 @@\n-old\n+new\n\n',
659
 
            differ.to_file.getvalue())
660
 
 
661
 
    def test_diff_deletion(self):
662
 
        self.build_tree_contents([('old-tree/file', 'contents'),
663
 
                                  ('new-tree/file', 'contents')])
664
 
        self.old_tree.add('file', 'file-id')
665
 
        self.new_tree.add('file', 'file-id')
666
 
        os.unlink('new-tree/file')
667
 
        self.differ.show_diff(None)
668
 
        self.assertContainsRe(self.differ.to_file.getvalue(), '-contents')
669
 
 
670
 
    def test_diff_creation(self):
671
 
        self.build_tree_contents([('old-tree/file', 'contents'),
672
 
                                  ('new-tree/file', 'contents')])
673
 
        self.old_tree.add('file', 'file-id')
674
 
        self.new_tree.add('file', 'file-id')
675
 
        os.unlink('old-tree/file')
676
 
        self.differ.show_diff(None)
677
 
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
678
 
 
679
 
    def test_diff_symlink(self):
680
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
681
 
        differ.diff_symlink('old target', None)
682
 
        self.assertEqual("=== target was 'old target'\n",
683
 
                         differ.to_file.getvalue())
684
 
 
685
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
686
 
        differ.diff_symlink(None, 'new target')
687
 
        self.assertEqual("=== target is 'new target'\n",
688
 
                         differ.to_file.getvalue())
689
 
 
690
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
691
 
        differ.diff_symlink('old target', 'new target')
692
 
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
693
 
                         differ.to_file.getvalue())
694
 
 
695
 
    def test_diff(self):
696
 
        self.build_tree_contents([('old-tree/olddir/',),
697
 
                                  ('old-tree/olddir/oldfile', 'old\n')])
698
 
        self.old_tree.add('olddir')
699
 
        self.old_tree.add('olddir/oldfile', 'file-id')
700
 
        self.build_tree_contents([('new-tree/newdir/',),
701
 
                                  ('new-tree/newdir/newfile', 'new\n')])
702
 
        self.new_tree.add('newdir')
703
 
        self.new_tree.add('newdir/newfile', 'file-id')
704
 
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
705
 
        self.assertContainsRe(
706
 
            self.differ.to_file.getvalue(),
707
 
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
708
 
             ' \@\@\n-old\n\+new\n\n')
709
 
 
710
 
    def test_diff_kind_change(self):
711
 
        self.requireFeature(tests.SymlinkFeature)
712
 
        self.build_tree_contents([('old-tree/olddir/',),
713
 
                                  ('old-tree/olddir/oldfile', 'old\n')])
714
 
        self.old_tree.add('olddir')
715
 
        self.old_tree.add('olddir/oldfile', 'file-id')
716
 
        self.build_tree(['new-tree/newdir/'])
717
 
        os.symlink('new', 'new-tree/newdir/newfile')
718
 
        self.new_tree.add('newdir')
719
 
        self.new_tree.add('newdir/newfile', 'file-id')
720
 
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
721
 
        self.assertContainsRe(
722
 
            self.differ.to_file.getvalue(),
723
 
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
724
 
             ' \@\@\n-old\n\n')
725
 
        self.assertContainsRe(self.differ.to_file.getvalue(),
726
 
                              "=== target is u'new'\n")
727
 
 
728
 
    def test_diff_directory(self):
729
 
        self.build_tree(['new-tree/new-dir/'])
730
 
        self.new_tree.add('new-dir', 'new-dir-id')
731
 
        self.differ.diff('new-dir-id', None, 'new-dir')
732
 
        self.assertEqual(self.differ.to_file.getvalue(), '')
733
 
 
734
 
    def create_old_new(self):
735
 
        self.build_tree_contents([('old-tree/olddir/',),
736
 
                                  ('old-tree/olddir/oldfile', 'old\n')])
737
 
        self.old_tree.add('olddir')
738
 
        self.old_tree.add('olddir/oldfile', 'file-id')
739
 
        self.build_tree_contents([('new-tree/newdir/',),
740
 
                                  ('new-tree/newdir/newfile', 'new\n')])
741
 
        self.new_tree.add('newdir')
742
 
        self.new_tree.add('newdir/newfile', 'file-id')
743
 
 
744
 
    def test_register_diff(self):
745
 
        self.create_old_new()
746
 
        old_diff_factories = diff.DiffTree.diff_factories
747
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
748
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
749
 
        try:
750
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
751
 
        finally:
752
 
            diff.DiffTree.diff_factories = old_diff_factories
753
 
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
754
 
        self.assertNotContainsRe(
755
 
            differ.to_file.getvalue(),
756
 
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
757
 
             ' \@\@\n-old\n\+new\n\n')
758
 
        self.assertContainsRe(differ.to_file.getvalue(),
759
 
                              'was: old\nis: new\n')
760
 
 
761
 
    def test_extra_factories(self):
762
 
        self.create_old_new()
763
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
764
 
                               extra_factories=[DiffWasIs.from_diff_tree])
765
 
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
766
 
        self.assertNotContainsRe(
767
 
            differ.to_file.getvalue(),
768
 
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
769
 
             ' \@\@\n-old\n\+new\n\n')
770
 
        self.assertContainsRe(differ.to_file.getvalue(),
771
 
                              'was: old\nis: new\n')
772
 
 
773
 
    def test_alphabetical_order(self):
774
 
        self.build_tree(['new-tree/a-file'])
775
 
        self.new_tree.add('a-file')
776
 
        self.build_tree(['old-tree/b-file'])
777
 
        self.old_tree.add('b-file')
778
 
        self.differ.show_diff(None)
779
 
        self.assertContainsRe(self.differ.to_file.getvalue(),
780
 
            '.*a-file(.|\n)*b-file')
781
 
 
782
 
 
783
 
class TestPatienceDiffLib(tests.TestCase):
784
 
 
785
 
    def setUp(self):
786
 
        super(TestPatienceDiffLib, self).setUp()
787
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
788
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
789
 
        self._PatienceSequenceMatcher = \
790
 
            _patiencediff_py.PatienceSequenceMatcher_py
791
 
 
792
 
    def test_diff_unicode_string(self):
793
 
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
794
 
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
795
 
        sm = self._PatienceSequenceMatcher(None, a, b)
796
 
        mb = sm.get_matching_blocks()
797
 
        self.assertEquals(35, len(mb))
 
248
 
 
249
class TestPatienceDiffLib(TestCase):
798
250
 
799
251
    def test_unique_lcs(self):
800
 
        unique_lcs = self._unique_lcs
 
252
        unique_lcs = bzrlib.patiencediff.unique_lcs
801
253
        self.assertEquals(unique_lcs('', ''), [])
802
 
        self.assertEquals(unique_lcs('', 'a'), [])
803
 
        self.assertEquals(unique_lcs('a', ''), [])
804
254
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
805
255
        self.assertEquals(unique_lcs('a', 'b'), [])
806
256
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
807
257
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
808
258
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
809
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
259
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
810
260
                                                         (3,3), (4,4)])
811
261
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
812
262
 
813
263
    def test_recurse_matches(self):
814
264
        def test_one(a, b, matches):
815
265
            test_matches = []
816
 
            self._recurse_matches(
817
 
                a, b, 0, 0, len(a), len(b), test_matches, 10)
 
266
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
 
267
                test_matches, 10)
818
268
            self.assertEquals(test_matches, matches)
819
269
 
820
270
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
821
271
                 [(0, 0), (2, 2), (4, 4)])
822
272
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
823
273
                 [(0, 0), (2, 1), (4, 2)])
824
 
        # Even though 'bc' is not unique globally, and is surrounded by
825
 
        # non-matching lines, we should still match, because they are locally
826
 
        # unique
827
 
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
828
 
                                          (4, 6), (5, 7), (6, 8)])
829
274
 
830
 
        # recurse_matches doesn't match non-unique
 
275
        # recurse_matches doesn't match non-unique 
831
276
        # lines surrounded by bogus text.
832
277
        # The update has been done in patiencediff.SequenceMatcher instead
833
278
 
837
282
        # This is what it currently gives:
838
283
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
839
284
 
840
 
    def assertDiffBlocks(self, a, b, expected_blocks):
841
 
        """Check that the sequence matcher returns the correct blocks.
842
 
 
843
 
        :param a: A sequence to match
844
 
        :param b: Another sequence to match
845
 
        :param expected_blocks: The expected output, not including the final
846
 
            matching block (len(a), len(b), 0)
847
 
        """
848
 
        matcher = self._PatienceSequenceMatcher(None, a, b)
849
 
        blocks = matcher.get_matching_blocks()
850
 
        last = blocks.pop()
851
 
        self.assertEqual((len(a), len(b), 0), last)
852
 
        self.assertEqual(expected_blocks, blocks)
853
 
 
854
285
    def test_matching_blocks(self):
 
286
        def chk_blocks(a, b, expected_blocks):
 
287
            # difflib always adds a signature of the total
 
288
            # length, with no matching entries at the end
 
289
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
290
            blocks = s.get_matching_blocks()
 
291
            self.assertEquals((len(a), len(b), 0), blocks[-1])
 
292
            self.assertEquals(expected_blocks, blocks[:-1])
 
293
 
855
294
        # Some basic matching tests
856
 
        self.assertDiffBlocks('', '', [])
857
 
        self.assertDiffBlocks([], [], [])
858
 
        self.assertDiffBlocks('abc', '', [])
859
 
        self.assertDiffBlocks('', 'abc', [])
860
 
        self.assertDiffBlocks('abcd', 'abcd', [(0, 0, 4)])
861
 
        self.assertDiffBlocks('abcd', 'abce', [(0, 0, 3)])
862
 
        self.assertDiffBlocks('eabc', 'abce', [(1, 0, 3)])
863
 
        self.assertDiffBlocks('eabce', 'abce', [(1, 0, 4)])
864
 
        self.assertDiffBlocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
865
 
        self.assertDiffBlocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
866
 
        self.assertDiffBlocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
867
 
        # This may check too much, but it checks to see that
 
295
        chk_blocks('', '', [])
 
296
        chk_blocks([], [], [])
 
297
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
 
298
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
 
299
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
 
300
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
 
301
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
 
302
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
 
303
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
 
304
        # This may check too much, but it checks to see that 
868
305
        # a copied block stays attached to the previous section,
869
306
        # not the later one.
870
307
        # difflib would tend to grab the trailing longest match
871
308
        # which would make the diff not look right
872
 
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
873
 
                              [(0, 0, 6), (6, 11, 10)])
 
309
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
310
                   [(0, 0, 6), (6, 11, 10)])
874
311
 
875
312
        # make sure it supports passing in lists
876
 
        self.assertDiffBlocks(
 
313
        chk_blocks(
877
314
                   ['hello there\n',
878
315
                    'world\n',
879
316
                    'how are you today?\n'],
883
320
 
884
321
        # non unique lines surrounded by non-matching lines
885
322
        # won't be found
886
 
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
323
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
887
324
 
888
325
        # But they only need to be locally unique
889
 
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
326
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
890
327
 
891
328
        # non unique blocks won't be matched
892
 
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
329
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
893
330
 
894
331
        # but locally unique ones will
895
 
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
332
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
896
333
                                              (5,4,1), (7,5,2), (10,8,1)])
897
334
 
898
 
        self.assertDiffBlocks('abbabbXd', 'cabbabxd', [(7,7,1)])
899
 
        self.assertDiffBlocks('abbabbbb', 'cabbabbc', [])
900
 
        self.assertDiffBlocks('bbbbbbbb', 'cbbbbbbc', [])
901
 
 
902
 
    def test_matching_blocks_tuples(self):
903
 
        # Some basic matching tests
904
 
        self.assertDiffBlocks([], [], [])
905
 
        self.assertDiffBlocks([('a',), ('b',), ('c,')], [], [])
906
 
        self.assertDiffBlocks([], [('a',), ('b',), ('c,')], [])
907
 
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
908
 
                              [('a',), ('b',), ('c,')],
909
 
                              [(0, 0, 3)])
910
 
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
911
 
                              [('a',), ('b',), ('d,')],
912
 
                              [(0, 0, 2)])
913
 
        self.assertDiffBlocks([('d',), ('b',), ('c,')],
914
 
                              [('a',), ('b',), ('c,')],
915
 
                              [(1, 1, 2)])
916
 
        self.assertDiffBlocks([('d',), ('a',), ('b',), ('c,')],
917
 
                              [('a',), ('b',), ('c,')],
918
 
                              [(1, 0, 3)])
919
 
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
920
 
                              [('a', 'b'), ('c', 'X'), ('e', 'f')],
921
 
                              [(0, 0, 1), (2, 2, 1)])
922
 
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
923
 
                              [('a', 'b'), ('c', 'dX'), ('e', 'f')],
924
 
                              [(0, 0, 1), (2, 2, 1)])
 
335
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
336
        chk_blocks('abbabbbb', 'cabbabbc', [])
 
337
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
925
338
 
926
339
    def test_opcodes(self):
927
340
        def chk_ops(a, b, expected_codes):
928
 
            s = self._PatienceSequenceMatcher(None, a, b)
 
341
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
929
342
            self.assertEquals(expected_codes, s.get_opcodes())
930
343
 
931
344
        chk_ops('', '', [])
932
345
        chk_ops([], [], [])
933
 
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
934
 
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
935
346
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
936
347
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
937
348
                                 ('replace', 3,4, 3,4)
970
381
                 ('delete', 1,2, 1,1),
971
382
                 ('equal',  2,3, 1,2),
972
383
                ])
973
 
        chk_ops('aBccDe', 'abccde',
 
384
        chk_ops('aBccDe', 'abccde', 
974
385
                [('equal',   0,1, 0,1),
975
386
                 ('replace', 1,5, 1,5),
976
387
                 ('equal',   5,6, 5,6),
977
388
                ])
978
 
        chk_ops('aBcDec', 'abcdec',
 
389
        chk_ops('aBcDec', 'abcdec', 
979
390
                [('equal',   0,1, 0,1),
980
391
                 ('replace', 1,2, 1,2),
981
392
                 ('equal',   2,3, 2,3),
982
393
                 ('replace', 3,4, 3,4),
983
394
                 ('equal',   4,6, 4,6),
984
395
                ])
985
 
        chk_ops('aBcdEcdFg', 'abcdecdfg',
 
396
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
986
397
                [('equal',   0,1, 0,1),
987
398
                 ('replace', 1,8, 1,8),
988
399
                 ('equal',   8,9, 8,9)
989
400
                ])
990
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
 
401
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
991
402
                [('equal',   0,1, 0,1),
992
403
                 ('replace', 1,2, 1,2),
993
404
                 ('equal',   2,4, 2,4),
999
410
                 ('equal',   10,11, 8,9)
1000
411
                ])
1001
412
 
1002
 
    def test_grouped_opcodes(self):
1003
 
        def chk_ops(a, b, expected_codes, n=3):
1004
 
            s = self._PatienceSequenceMatcher(None, a, b)
1005
 
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
1006
 
 
1007
 
        chk_ops('', '', [])
1008
 
        chk_ops([], [], [])
1009
 
        chk_ops('abc', '', [[('delete', 0,3, 0,0)]])
1010
 
        chk_ops('', 'abc', [[('insert', 0,0, 0,3)]])
1011
 
        chk_ops('abcd', 'abcd', [])
1012
 
        chk_ops('abcd', 'abce', [[('equal',   0,3, 0,3),
1013
 
                                  ('replace', 3,4, 3,4)
1014
 
                                 ]])
1015
 
        chk_ops('eabc', 'abce', [[('delete', 0,1, 0,0),
1016
 
                                 ('equal',  1,4, 0,3),
1017
 
                                 ('insert', 4,4, 3,4)
1018
 
                                ]])
1019
 
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
1020
 
                [[('equal',  3,6, 3,6),
1021
 
                  ('insert', 6,6, 6,11),
1022
 
                  ('equal',  6,9, 11,14)
1023
 
                  ]])
1024
 
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
1025
 
                [[('equal',  2,6, 2,6),
1026
 
                  ('insert', 6,6, 6,11),
1027
 
                  ('equal',  6,10, 11,15)
1028
 
                  ]], 4)
1029
 
        chk_ops('Xabcdef', 'abcdef',
1030
 
                [[('delete', 0,1, 0,0),
1031
 
                  ('equal',  1,4, 0,3)
1032
 
                  ]])
1033
 
        chk_ops('abcdef', 'abcdefX',
1034
 
                [[('equal',  3,6, 3,6),
1035
 
                  ('insert', 6,6, 6,7)
1036
 
                  ]])
1037
 
 
1038
 
 
1039
413
    def test_multiple_ranges(self):
1040
414
        # There was an earlier bug where we used a bad set of ranges,
1041
415
        # this triggers that specific bug, to make sure it doesn't regress
1042
 
        self.assertDiffBlocks('abcdefghijklmnop',
1043
 
                              'abcXghiYZQRSTUVWXYZijklmnop',
1044
 
                              [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
1045
 
 
1046
 
        self.assertDiffBlocks('ABCd efghIjk  L',
1047
 
                              'AxyzBCn mo pqrstuvwI1 2  L',
1048
 
                              [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
 
416
        def chk_blocks(a, b, expected_blocks):
 
417
            # difflib always adds a signature of the total
 
418
            # length, with no matching entries at the end
 
419
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
420
            blocks = s.get_matching_blocks()
 
421
            x = blocks.pop()
 
422
            self.assertEquals(x, (len(a), len(b), 0))
 
423
            self.assertEquals(expected_blocks, blocks)
 
424
 
 
425
        chk_blocks('abcdefghijklmnop'
 
426
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
 
427
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
 
428
 
 
429
        chk_blocks('ABCd efghIjk  L'
 
430
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
 
431
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
1049
432
 
1050
433
        # These are rot13 code snippets.
1051
 
        self.assertDiffBlocks('''\
 
434
        chk_blocks('''\
1052
435
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1053
436
    """
1054
437
    gnxrf_netf = ['svyr*']
1055
438
    gnxrf_bcgvbaf = ['ab-erphefr']
1056
 
 
 
439
  
1057
440
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1058
441
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1059
442
        vs vf_dhvrg():
1067
450
'''.splitlines(True), '''\
1068
451
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1069
452
 
1070
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
 
453
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
1071
454
    nqq gurz.
1072
455
    """
1073
456
    gnxrf_netf = ['svyr*']
1100
483
                 'how are you today?\n']
1101
484
        txt_b = ['hello there\n',
1102
485
                 'how are you today?\n']
1103
 
        unified_diff = patiencediff.unified_diff
1104
 
        psm = self._PatienceSequenceMatcher
1105
 
        self.assertEquals(['--- \n',
1106
 
                           '+++ \n',
 
486
        unified_diff = bzrlib.patiencediff.unified_diff
 
487
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
488
        self.assertEquals([ '---  \n',
 
489
                           '+++  \n',
1107
490
                           '@@ -1,3 +1,2 @@\n',
1108
491
                           ' hello there\n',
1109
492
                           '-world\n',
1114
497
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1115
498
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1116
499
        # This is the result with LongestCommonSubstring matching
1117
 
        self.assertEquals(['--- \n',
1118
 
                           '+++ \n',
 
500
        self.assertEquals(['---  \n',
 
501
                           '+++  \n',
1119
502
                           '@@ -1,6 +1,11 @@\n',
1120
503
                           ' a\n',
1121
504
                           ' b\n',
1130
513
                           ' f\n']
1131
514
                          , list(unified_diff(txt_a, txt_b)))
1132
515
        # And the patience diff
1133
 
        self.assertEquals(['--- \n',
1134
 
                           '+++ \n',
 
516
        self.assertEquals(['---  \n',
 
517
                           '+++  \n',
1135
518
                           '@@ -4,6 +4,11 @@\n',
1136
519
                           ' d\n',
1137
520
                           ' e\n',
1148
531
                          , list(unified_diff(txt_a, txt_b,
1149
532
                                 sequencematcher=psm)))
1150
533
 
1151
 
    def test_patience_unified_diff_with_dates(self):
1152
 
        txt_a = ['hello there\n',
1153
 
                 'world\n',
1154
 
                 'how are you today?\n']
1155
 
        txt_b = ['hello there\n',
1156
 
                 'how are you today?\n']
1157
 
        unified_diff = patiencediff.unified_diff
1158
 
        psm = self._PatienceSequenceMatcher
1159
 
        self.assertEquals(['--- a\t2008-08-08\n',
1160
 
                           '+++ b\t2008-09-09\n',
1161
 
                           '@@ -1,3 +1,2 @@\n',
1162
 
                           ' hello there\n',
1163
 
                           '-world\n',
1164
 
                           ' how are you today?\n'
1165
 
                          ]
1166
 
                          , list(unified_diff(txt_a, txt_b,
1167
 
                                 fromfile='a', tofile='b',
1168
 
                                 fromfiledate='2008-08-08',
1169
 
                                 tofiledate='2008-09-09',
1170
 
                                 sequencematcher=psm)))
1171
 
 
1172
 
 
1173
 
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1174
 
 
1175
 
    _test_needs_features = [compiled_patiencediff_feature]
1176
 
 
1177
 
    def setUp(self):
1178
 
        super(TestPatienceDiffLib_c, self).setUp()
1179
 
        from bzrlib import _patiencediff_c
1180
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1181
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
1182
 
        self._PatienceSequenceMatcher = \
1183
 
            _patiencediff_c.PatienceSequenceMatcher_c
1184
 
 
1185
 
    def test_unhashable(self):
1186
 
        """We should get a proper exception here."""
1187
 
        # We need to be able to hash items in the sequence, lists are
1188
 
        # unhashable, and thus cannot be diffed
1189
 
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1190
 
                                         None, [[]], [])
1191
 
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1192
 
                                         None, ['valid', []], [])
1193
 
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1194
 
                                         None, ['valid'], [[]])
1195
 
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1196
 
                                         None, ['valid'], ['valid', []])
1197
 
 
1198
 
 
1199
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
1200
 
 
1201
 
    def setUp(self):
1202
 
        super(TestPatienceDiffLibFiles, self).setUp()
1203
 
        self._PatienceSequenceMatcher = \
1204
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
534
 
 
535
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1205
536
 
1206
537
    def test_patience_unified_diff_files(self):
1207
538
        txt_a = ['hello there\n',
1212
543
        open('a1', 'wb').writelines(txt_a)
1213
544
        open('b1', 'wb').writelines(txt_b)
1214
545
 
1215
 
        unified_diff_files = patiencediff.unified_diff_files
1216
 
        psm = self._PatienceSequenceMatcher
1217
 
        self.assertEquals(['--- a1\n',
1218
 
                           '+++ b1\n',
 
546
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
 
547
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
548
        self.assertEquals(['--- a1 \n',
 
549
                           '+++ b1 \n',
1219
550
                           '@@ -1,3 +1,2 @@\n',
1220
551
                           ' hello there\n',
1221
552
                           '-world\n',
1230
561
        open('b2', 'wb').writelines(txt_b)
1231
562
 
1232
563
        # This is the result with LongestCommonSubstring matching
1233
 
        self.assertEquals(['--- a2\n',
1234
 
                           '+++ b2\n',
 
564
        self.assertEquals(['--- a2 \n',
 
565
                           '+++ b2 \n',
1235
566
                           '@@ -1,6 +1,11 @@\n',
1236
567
                           ' a\n',
1237
568
                           ' b\n',
1247
578
                          , list(unified_diff_files('a2', 'b2')))
1248
579
 
1249
580
        # And the patience diff
1250
 
        self.assertEquals(['--- a2\n',
1251
 
                           '+++ b2\n',
 
581
        self.assertEquals(['--- a2 \n',
 
582
                           '+++ b2 \n',
1252
583
                           '@@ -4,6 +4,11 @@\n',
1253
584
                           ' d\n',
1254
585
                           ' e\n',
1264
595
                          ]
1265
596
                          , list(unified_diff_files('a2', 'b2',
1266
597
                                 sequencematcher=psm)))
1267
 
 
1268
 
 
1269
 
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1270
 
 
1271
 
    _test_needs_features = [compiled_patiencediff_feature]
1272
 
 
1273
 
    def setUp(self):
1274
 
        super(TestPatienceDiffLibFiles_c, self).setUp()
1275
 
        from bzrlib import _patiencediff_c
1276
 
        self._PatienceSequenceMatcher = \
1277
 
            _patiencediff_c.PatienceSequenceMatcher_c
1278
 
 
1279
 
 
1280
 
class TestUsingCompiledIfAvailable(tests.TestCase):
1281
 
 
1282
 
    def test_PatienceSequenceMatcher(self):
1283
 
        if compiled_patiencediff_feature.available():
1284
 
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1285
 
            self.assertIs(PatienceSequenceMatcher_c,
1286
 
                          patiencediff.PatienceSequenceMatcher)
1287
 
        else:
1288
 
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1289
 
            self.assertIs(PatienceSequenceMatcher_py,
1290
 
                          patiencediff.PatienceSequenceMatcher)
1291
 
 
1292
 
    def test_unique_lcs(self):
1293
 
        if compiled_patiencediff_feature.available():
1294
 
            from bzrlib._patiencediff_c import unique_lcs_c
1295
 
            self.assertIs(unique_lcs_c,
1296
 
                          patiencediff.unique_lcs)
1297
 
        else:
1298
 
            from bzrlib._patiencediff_py import unique_lcs_py
1299
 
            self.assertIs(unique_lcs_py,
1300
 
                          patiencediff.unique_lcs)
1301
 
 
1302
 
    def test_recurse_matches(self):
1303
 
        if compiled_patiencediff_feature.available():
1304
 
            from bzrlib._patiencediff_c import recurse_matches_c
1305
 
            self.assertIs(recurse_matches_c,
1306
 
                          patiencediff.recurse_matches)
1307
 
        else:
1308
 
            from bzrlib._patiencediff_py import recurse_matches_py
1309
 
            self.assertIs(recurse_matches_py,
1310
 
                          patiencediff.recurse_matches)
1311
 
 
1312
 
 
1313
 
class TestDiffFromTool(tests.TestCaseWithTransport):
1314
 
 
1315
 
    def test_from_string(self):
1316
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
1317
 
        self.addCleanup(diff_obj.finish)
1318
 
        self.assertEqual(['diff', '@old_path', '@new_path'],
1319
 
            diff_obj.command_template)
1320
 
 
1321
 
    def test_from_string_u5(self):
1322
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1323
 
                                                 None, None, None)
1324
 
        self.addCleanup(diff_obj.finish)
1325
 
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1326
 
                         diff_obj.command_template)
1327
 
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1328
 
                         diff_obj._get_command('old-path', 'new-path'))
1329
 
 
1330
 
    def test_from_string_path_with_backslashes(self):
1331
 
        self.requireFeature(features.backslashdir_feature)
1332
 
        tool = 'C:\\Tools\\Diff.exe'
1333
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1334
 
        self.addCleanup(diff_obj.finish)
1335
 
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1336
 
                         diff_obj.command_template)
1337
 
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1338
 
                         diff_obj._get_command('old-path', 'new-path'))
1339
 
 
1340
 
    def test_execute(self):
1341
 
        output = StringIO()
1342
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1343
 
                                      'print "@old_path @new_path"'],
1344
 
                                     None, None, output)
1345
 
        self.addCleanup(diff_obj.finish)
1346
 
        diff_obj._execute('old', 'new')
1347
 
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1348
 
 
1349
 
    def test_excute_missing(self):
1350
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1351
 
                                     None, None, None)
1352
 
        self.addCleanup(diff_obj.finish)
1353
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1354
 
                              'old', 'new')
1355
 
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1356
 
                         ' on this machine', str(e))
1357
 
 
1358
 
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1359
 
        self.requireFeature(AttribFeature)
1360
 
        output = StringIO()
1361
 
        tree = self.make_branch_and_tree('tree')
1362
 
        self.build_tree_contents([('tree/file', 'content')])
1363
 
        tree.add('file', 'file-id')
1364
 
        tree.commit('old tree')
1365
 
        tree.lock_read()
1366
 
        self.addCleanup(tree.unlock)
1367
 
        basis_tree = tree.basis_tree()
1368
 
        basis_tree.lock_read()
1369
 
        self.addCleanup(basis_tree.unlock)
1370
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1371
 
                                      'print "@old_path @new_path"'],
1372
 
                                     basis_tree, tree, output)
1373
 
        diff_obj._prepare_files('file-id', 'file', 'file')
1374
 
        # The old content should be readonly
1375
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1376
 
                                    r'R.*old\\file$')
1377
 
        # The new content should use the tree object, not a 'new' file anymore
1378
 
        self.assertEndsWith(tree.basedir, 'work/tree')
1379
 
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1380
 
 
1381
 
    def assertReadableByAttrib(self, cwd, relpath, regex):
1382
 
        proc = subprocess.Popen(['attrib', relpath],
1383
 
                                stdout=subprocess.PIPE,
1384
 
                                cwd=cwd)
1385
 
        (result, err) = proc.communicate()
1386
 
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1387
 
 
1388
 
    def test_prepare_files(self):
1389
 
        output = StringIO()
1390
 
        tree = self.make_branch_and_tree('tree')
1391
 
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
1392
 
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1393
 
        tree.add('oldname', 'file-id')
1394
 
        tree.add('oldname2', 'file2-id')
1395
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1396
 
        tree.commit('old tree', timestamp=315532800)
1397
 
        tree.rename_one('oldname', 'newname')
1398
 
        tree.rename_one('oldname2', 'newname2')
1399
 
        self.build_tree_contents([('tree/newname', 'newcontent')])
1400
 
        self.build_tree_contents([('tree/newname2', 'newcontent2')])
1401
 
        old_tree = tree.basis_tree()
1402
 
        old_tree.lock_read()
1403
 
        self.addCleanup(old_tree.unlock)
1404
 
        tree.lock_read()
1405
 
        self.addCleanup(tree.unlock)
1406
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1407
 
                                      'print "@old_path @new_path"'],
1408
 
                                     old_tree, tree, output)
1409
 
        self.addCleanup(diff_obj.finish)
1410
 
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1411
 
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1412
 
                                                     'newname')
1413
 
        self.assertContainsRe(old_path, 'old/oldname$')
1414
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
1415
 
        self.assertContainsRe(new_path, 'tree/newname$')
1416
 
        self.assertFileEqual('oldcontent', old_path)
1417
 
        self.assertFileEqual('newcontent', new_path)
1418
 
        if osutils.host_os_dereferences_symlinks():
1419
 
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1420
 
        # make sure we can create files with the same parent directories
1421
 
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1422
 
 
1423
 
 
1424
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1425
 
 
1426
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1427
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1428
 
        TestGetTreesAndBranchesToDiff.
1429
 
        """
1430
 
        return diff.get_trees_and_branches_to_diff_locked(
1431
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1432
 
 
1433
 
    def test_basic(self):
1434
 
        tree = self.make_branch_and_tree('tree')
1435
 
        (old_tree, new_tree,
1436
 
         old_branch, new_branch,
1437
 
         specific_files, extra_trees) = self.call_gtabtd(
1438
 
             ['tree'], None, None, None)
1439
 
 
1440
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1441
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1442
 
                         old_tree.get_revision_id())
1443
 
        self.assertEqual(tree.basedir, new_tree.basedir)
1444
 
        self.assertEqual(tree.branch.base, old_branch.base)
1445
 
        self.assertEqual(tree.branch.base, new_branch.base)
1446
 
        self.assertIs(None, specific_files)
1447
 
        self.assertIs(None, extra_trees)
1448
 
 
1449
 
    def test_with_rev_specs(self):
1450
 
        tree = self.make_branch_and_tree('tree')
1451
 
        self.build_tree_contents([('tree/file', 'oldcontent')])
1452
 
        tree.add('file', 'file-id')
1453
 
        tree.commit('old tree', timestamp=0, rev_id="old-id")
1454
 
        self.build_tree_contents([('tree/file', 'newcontent')])
1455
 
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1456
 
 
1457
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1458
 
                     revisionspec.RevisionSpec.from_string('2')]
1459
 
        (old_tree, new_tree,
1460
 
         old_branch, new_branch,
1461
 
         specific_files, extra_trees) = self.call_gtabtd(
1462
 
            ['tree'], revisions, None, None)
1463
 
 
1464
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1465
 
        self.assertEqual("old-id", old_tree.get_revision_id())
1466
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
1467
 
        self.assertEqual("new-id", new_tree.get_revision_id())
1468
 
        self.assertEqual(tree.branch.base, old_branch.base)
1469
 
        self.assertEqual(tree.branch.base, new_branch.base)
1470
 
        self.assertIs(None, specific_files)
1471
 
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1472
 
 
1473
 
 
1474
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1475
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1476
 
    deprecated get_trees_and_branches_to_diff function.
1477
 
    """
1478
 
 
1479
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1480
 
        return self.applyDeprecated(
1481
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1482
 
            path_list, revision_specs, old_url, new_url)