← 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: INADA Naoki
  • Date: 2011-05-05 09:15:34 UTC
  • mto: (5830.3.3 i18n-msgfmt)
  • mto: This revision was merged to the branch mainline in revision 5873.
  • Revision ID: songofacandy@gmail.com-20110505091534-7sv835xpofwrmpt4
Add update-pot command to Makefile and tools/bzrgettext script that
extracts help text from bzr commands.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Development Ltd
 
1
# Copyright (C) 2005-2011 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
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
18
18
from cStringIO import StringIO
19
 
import errno
20
19
import subprocess
21
 
from tempfile import TemporaryFile
22
 
 
23
 
from bzrlib.diff import internal_diff, external_diff, show_diff_trees
24
 
from bzrlib.errors import BinaryFile, NoDiff
25
 
import bzrlib.patiencediff
26
 
from bzrlib.tests import (TestCase, TestCaseWithTransport,
27
 
                          TestCaseInTempDir, TestSkipped)
 
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')
28
59
 
29
60
 
30
61
def udiff_lines(old, new, allow_binary=False):
31
62
    output = StringIO()
32
 
    internal_diff('old', old, 'new', new, output, allow_binary)
 
63
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
33
64
    output.seek(0, 0)
34
65
    return output.readlines()
35
66
 
39
70
        # StringIO has no fileno, so it tests a different codepath
40
71
        output = StringIO()
41
72
    else:
42
 
        output = TemporaryFile()
 
73
        output = tempfile.TemporaryFile()
43
74
    try:
44
 
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
45
 
    except NoDiff:
46
 
        raise TestSkipped('external "diff" not present to test')
 
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')
47
78
    output.seek(0, 0)
48
79
    lines = output.readlines()
49
80
    output.close()
50
81
    return lines
51
82
 
52
83
 
53
 
class TestDiff(TestCase):
 
84
class TestDiff(tests.TestCase):
54
85
 
55
86
    def test_add_nl(self):
56
87
        """diff generates a valid diff for patches that add a newline"""
92
123
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
93
124
 
94
125
    def test_binary_lines(self):
95
 
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
96
 
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
97
 
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
98
 
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
 
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)
99
132
 
100
133
    def test_external_diff(self):
101
134
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
111
144
        self.check_patch(lines)
112
145
 
113
146
    def test_external_diff_binary_lang_c(self):
114
 
        orig_lang = os.environ.get('LANG')
115
 
        try:
116
 
            os.environ['LANG'] = 'C'
117
 
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
118
 
            # Older versions of diffutils say "Binary files", newer
119
 
            # versions just say "Files".
120
 
            self.assertContainsRe(lines[0],
121
 
                                  '(Binary f|F)iles old and new differ\n')
122
 
            self.assertEquals(lines[1:], ['\n'])
123
 
        finally:
124
 
            if orig_lang is None:
125
 
                del os.environ['LANG']
126
 
            else:
127
 
                os.environ['LANG'] = orig_lang
 
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'])
128
154
 
129
155
    def test_no_external_diff(self):
130
156
        """Check that NoDiff is raised when diff is not available"""
131
 
        # Use os.environ['PATH'] to make sure no 'diff' command is available
132
 
        orig_path = os.environ['PATH']
133
 
        try:
134
 
            os.environ['PATH'] = ''
135
 
            self.assertRaises(NoDiff, external_diff,
136
 
                              'old', ['boo\n'], 'new', ['goo\n'],
137
 
                              StringIO(), diff_opts=['-u'])
138
 
        finally:
139
 
            os.environ['PATH'] = orig_path
140
 
        
 
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'])
 
163
 
141
164
    def test_internal_diff_default(self):
142
165
        # Default internal diff encoding is utf8
143
166
        output = StringIO()
144
 
        internal_diff(u'old_\xb5', ['old_text\n'],
145
 
                    u'new_\xe5', ['new_text\n'], output)
 
167
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
168
                           u'new_\xe5', ['new_text\n'], output)
146
169
        lines = output.getvalue().splitlines(True)
147
170
        self.check_patch(lines)
148
171
        self.assertEquals(['--- old_\xc2\xb5\n',
156
179
 
157
180
    def test_internal_diff_utf8(self):
158
181
        output = StringIO()
159
 
        internal_diff(u'old_\xb5', ['old_text\n'],
160
 
                    u'new_\xe5', ['new_text\n'], output,
161
 
                    path_encoding='utf8')
 
182
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
183
                           u'new_\xe5', ['new_text\n'], output,
 
184
                           path_encoding='utf8')
162
185
        lines = output.getvalue().splitlines(True)
163
186
        self.check_patch(lines)
164
187
        self.assertEquals(['--- old_\xc2\xb5\n',
172
195
 
173
196
    def test_internal_diff_iso_8859_1(self):
174
197
        output = StringIO()
175
 
        internal_diff(u'old_\xb5', ['old_text\n'],
176
 
                    u'new_\xe5', ['new_text\n'], output,
177
 
                    path_encoding='iso-8859-1')
 
198
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
199
                           u'new_\xe5', ['new_text\n'], output,
 
200
                           path_encoding='iso-8859-1')
178
201
        lines = output.getvalue().splitlines(True)
179
202
        self.check_patch(lines)
180
203
        self.assertEquals(['--- old_\xb5\n',
186
209
                          ]
187
210
                          , lines)
188
211
 
 
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
 
189
224
    def test_internal_diff_returns_bytes(self):
190
225
        import StringIO
191
226
        output = StringIO.StringIO()
192
 
        internal_diff(u'old_\xb5', ['old_text\n'],
193
 
                    u'new_\xe5', ['new_text\n'], output)
194
 
        self.failUnless(isinstance(output.getvalue(), str),
 
227
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
228
                            u'new_\xe5', ['new_text\n'], output)
 
229
        self.assertIsInstance(output.getvalue(), str,
195
230
            'internal_diff should return bytestrings')
196
231
 
197
232
 
198
 
class TestDiffFiles(TestCaseInTempDir):
 
233
class TestDiffFiles(tests.TestCaseInTempDir):
199
234
 
200
235
    def test_external_diff_binary(self):
201
236
        """The output when using external diff should use diff's i18n error"""
202
237
        # Make sure external_diff doesn't fail in the current LANG
203
238
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
204
239
 
205
 
        cmd = ['diff', '-u', 'old', 'new']
 
240
        cmd = ['diff', '-u', '--binary', 'old', 'new']
206
241
        open('old', 'wb').write('\x00foobar\n')
207
242
        open('new', 'wb').write('foo\x00bar\n')
208
243
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
214
249
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
215
250
 
216
251
 
217
 
class TestDiffDates(TestCaseWithTransport):
 
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):
218
266
 
219
267
    def setUp(self):
220
268
        super(TestDiffDates, self).setUp()
254
302
        # set the date stamps for files in the working tree to known values
255
303
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
256
304
 
257
 
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
258
 
        output = StringIO()
259
 
        if working_tree is not None:
260
 
            extra_trees = (working_tree,)
261
 
        else:
262
 
            extra_trees = ()
263
 
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
264
 
                        extra_trees=extra_trees, old_label='old/', 
265
 
                        new_label='new/')
266
 
        return output.getvalue()
267
 
 
268
305
    def test_diff_rev_tree_working_tree(self):
269
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
306
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
270
307
        # note that the date for old/file1 is from rev 2 rather than from
271
308
        # the basis revision (rev 4)
272
309
        self.assertEqualDiff(output, '''\
282
319
    def test_diff_rev_tree_rev_tree(self):
283
320
        tree1 = self.b.repository.revision_tree('rev-2')
284
321
        tree2 = self.b.repository.revision_tree('rev-3')
285
 
        output = self.get_diff(tree1, tree2)
 
322
        output = get_diff_as_string(tree1, tree2)
286
323
        self.assertEqualDiff(output, '''\
287
324
=== modified file 'file2'
288
325
--- old/file2\t2006-04-01 00:00:00 +0000
292
329
+file2 contents at rev 3
293
330
 
294
331
''')
295
 
        
 
332
 
296
333
    def test_diff_add_files(self):
297
 
        tree1 = self.b.repository.revision_tree(None)
 
334
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
298
335
        tree2 = self.b.repository.revision_tree('rev-1')
299
 
        output = self.get_diff(tree1, tree2)
 
336
        output = get_diff_as_string(tree1, tree2)
300
337
        # the files have the epoch time stamp for the tree in which
301
338
        # they don't exist.
302
339
        self.assertEqualDiff(output, '''\
317
354
    def test_diff_remove_files(self):
318
355
        tree1 = self.b.repository.revision_tree('rev-3')
319
356
        tree2 = self.b.repository.revision_tree('rev-4')
320
 
        output = self.get_diff(tree1, tree2)
 
357
        output = get_diff_as_string(tree1, tree2)
321
358
        # the file has the epoch time stamp for the tree in which
322
359
        # it doesn't exist.
323
360
        self.assertEqualDiff(output, '''\
334
371
        self.wt.rename_one('file1', 'file1b')
335
372
        old_tree = self.b.repository.revision_tree('rev-1')
336
373
        new_tree = self.b.repository.revision_tree('rev-4')
337
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
374
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
338
375
                            working_tree=self.wt)
339
376
        self.assertContainsRe(out, 'file1\t')
340
377
 
346
383
        self.wt.rename_one('file1', 'dir1/file1')
347
384
        old_tree = self.b.repository.revision_tree('rev-1')
348
385
        new_tree = self.b.repository.revision_tree('rev-4')
349
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
386
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
350
387
                            working_tree=self.wt)
351
388
        self.assertContainsRe(out, 'file1\t')
352
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
389
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
353
390
                            working_tree=self.wt)
354
391
        self.assertNotContainsRe(out, 'file1\t')
355
392
 
356
393
 
357
 
class TestPatienceDiffLib(TestCase):
 
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))
358
798
 
359
799
    def test_unique_lcs(self):
360
 
        unique_lcs = bzrlib.patiencediff.unique_lcs
 
800
        unique_lcs = self._unique_lcs
361
801
        self.assertEquals(unique_lcs('', ''), [])
 
802
        self.assertEquals(unique_lcs('', 'a'), [])
 
803
        self.assertEquals(unique_lcs('a', ''), [])
362
804
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
363
805
        self.assertEquals(unique_lcs('a', 'b'), [])
364
806
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
365
807
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
366
808
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
367
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
 
809
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
368
810
                                                         (3,3), (4,4)])
369
811
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
370
812
 
371
813
    def test_recurse_matches(self):
372
814
        def test_one(a, b, matches):
373
815
            test_matches = []
374
 
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
375
 
                test_matches, 10)
 
816
            self._recurse_matches(
 
817
                a, b, 0, 0, len(a), len(b), test_matches, 10)
376
818
            self.assertEquals(test_matches, matches)
377
819
 
378
820
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
379
821
                 [(0, 0), (2, 2), (4, 4)])
380
822
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
381
823
                 [(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)])
382
829
 
383
 
        # recurse_matches doesn't match non-unique 
 
830
        # recurse_matches doesn't match non-unique
384
831
        # lines surrounded by bogus text.
385
832
        # The update has been done in patiencediff.SequenceMatcher instead
386
833
 
390
837
        # This is what it currently gives:
391
838
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
392
839
 
 
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
 
393
854
    def test_matching_blocks(self):
394
 
        def chk_blocks(a, b, expected_blocks):
395
 
            # difflib always adds a signature of the total
396
 
            # length, with no matching entries at the end
397
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
398
 
            blocks = s.get_matching_blocks()
399
 
            self.assertEquals((len(a), len(b), 0), blocks[-1])
400
 
            self.assertEquals(expected_blocks, blocks[:-1])
401
 
 
402
855
        # Some basic matching tests
403
 
        chk_blocks('', '', [])
404
 
        chk_blocks([], [], [])
405
 
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
406
 
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
407
 
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
408
 
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
409
 
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
410
 
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
411
 
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
412
 
        # This may check too much, but it checks to see that 
 
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
413
868
        # a copied block stays attached to the previous section,
414
869
        # not the later one.
415
870
        # difflib would tend to grab the trailing longest match
416
871
        # which would make the diff not look right
417
 
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
418
 
                   [(0, 0, 6), (6, 11, 10)])
 
872
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
873
                              [(0, 0, 6), (6, 11, 10)])
419
874
 
420
875
        # make sure it supports passing in lists
421
 
        chk_blocks(
 
876
        self.assertDiffBlocks(
422
877
                   ['hello there\n',
423
878
                    'world\n',
424
879
                    'how are you today?\n'],
428
883
 
429
884
        # non unique lines surrounded by non-matching lines
430
885
        # won't be found
431
 
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
886
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
432
887
 
433
888
        # But they only need to be locally unique
434
 
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
889
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
435
890
 
436
891
        # non unique blocks won't be matched
437
 
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
892
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
438
893
 
439
894
        # but locally unique ones will
440
 
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
895
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
441
896
                                              (5,4,1), (7,5,2), (10,8,1)])
442
897
 
443
 
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
444
 
        chk_blocks('abbabbbb', 'cabbabbc', [])
445
 
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
 
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)])
446
925
 
447
926
    def test_opcodes(self):
448
927
        def chk_ops(a, b, expected_codes):
449
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
928
            s = self._PatienceSequenceMatcher(None, a, b)
450
929
            self.assertEquals(expected_codes, s.get_opcodes())
451
930
 
452
931
        chk_ops('', '', [])
453
932
        chk_ops([], [], [])
 
933
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
 
934
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
454
935
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
455
936
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
456
937
                                 ('replace', 3,4, 3,4)
489
970
                 ('delete', 1,2, 1,1),
490
971
                 ('equal',  2,3, 1,2),
491
972
                ])
492
 
        chk_ops('aBccDe', 'abccde', 
 
973
        chk_ops('aBccDe', 'abccde',
493
974
                [('equal',   0,1, 0,1),
494
975
                 ('replace', 1,5, 1,5),
495
976
                 ('equal',   5,6, 5,6),
496
977
                ])
497
 
        chk_ops('aBcDec', 'abcdec', 
 
978
        chk_ops('aBcDec', 'abcdec',
498
979
                [('equal',   0,1, 0,1),
499
980
                 ('replace', 1,2, 1,2),
500
981
                 ('equal',   2,3, 2,3),
501
982
                 ('replace', 3,4, 3,4),
502
983
                 ('equal',   4,6, 4,6),
503
984
                ])
504
 
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
 
985
        chk_ops('aBcdEcdFg', 'abcdecdfg',
505
986
                [('equal',   0,1, 0,1),
506
987
                 ('replace', 1,8, 1,8),
507
988
                 ('equal',   8,9, 8,9)
508
989
                ])
509
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
990
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
510
991
                [('equal',   0,1, 0,1),
511
992
                 ('replace', 1,2, 1,2),
512
993
                 ('equal',   2,4, 2,4),
518
999
                 ('equal',   10,11, 8,9)
519
1000
                ])
520
1001
 
 
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
 
521
1039
    def test_multiple_ranges(self):
522
1040
        # There was an earlier bug where we used a bad set of ranges,
523
1041
        # this triggers that specific bug, to make sure it doesn't regress
524
 
        def chk_blocks(a, b, expected_blocks):
525
 
            # difflib always adds a signature of the total
526
 
            # length, with no matching entries at the end
527
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
528
 
            blocks = s.get_matching_blocks()
529
 
            x = blocks.pop()
530
 
            self.assertEquals(x, (len(a), len(b), 0))
531
 
            self.assertEquals(expected_blocks, blocks)
532
 
 
533
 
        chk_blocks('abcdefghijklmnop'
534
 
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
535
 
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
536
 
 
537
 
        chk_blocks('ABCd efghIjk  L'
538
 
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
539
 
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
 
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)])
540
1049
 
541
1050
        # These are rot13 code snippets.
542
 
        chk_blocks('''\
 
1051
        self.assertDiffBlocks('''\
543
1052
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
544
1053
    """
545
1054
    gnxrf_netf = ['svyr*']
546
1055
    gnxrf_bcgvbaf = ['ab-erphefr']
547
 
  
 
1056
 
548
1057
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
549
1058
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
550
1059
        vs vf_dhvrg():
558
1067
'''.splitlines(True), '''\
559
1068
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
560
1069
 
561
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
 
1070
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
562
1071
    nqq gurz.
563
1072
    """
564
1073
    gnxrf_netf = ['svyr*']
591
1100
                 'how are you today?\n']
592
1101
        txt_b = ['hello there\n',
593
1102
                 'how are you today?\n']
594
 
        unified_diff = bzrlib.patiencediff.unified_diff
595
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
596
 
        self.assertEquals([ '---  \n',
597
 
                           '+++  \n',
 
1103
        unified_diff = patiencediff.unified_diff
 
1104
        psm = self._PatienceSequenceMatcher
 
1105
        self.assertEquals(['--- \n',
 
1106
                           '+++ \n',
598
1107
                           '@@ -1,3 +1,2 @@\n',
599
1108
                           ' hello there\n',
600
1109
                           '-world\n',
605
1114
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
606
1115
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
607
1116
        # This is the result with LongestCommonSubstring matching
608
 
        self.assertEquals(['---  \n',
609
 
                           '+++  \n',
 
1117
        self.assertEquals(['--- \n',
 
1118
                           '+++ \n',
610
1119
                           '@@ -1,6 +1,11 @@\n',
611
1120
                           ' a\n',
612
1121
                           ' b\n',
621
1130
                           ' f\n']
622
1131
                          , list(unified_diff(txt_a, txt_b)))
623
1132
        # And the patience diff
624
 
        self.assertEquals(['---  \n',
625
 
                           '+++  \n',
 
1133
        self.assertEquals(['--- \n',
 
1134
                           '+++ \n',
626
1135
                           '@@ -4,6 +4,11 @@\n',
627
1136
                           ' d\n',
628
1137
                           ' e\n',
639
1148
                          , list(unified_diff(txt_a, txt_b,
640
1149
                                 sequencematcher=psm)))
641
1150
 
642
 
 
643
 
class TestPatienceDiffLibFiles(TestCaseInTempDir):
 
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
644
1205
 
645
1206
    def test_patience_unified_diff_files(self):
646
1207
        txt_a = ['hello there\n',
651
1212
        open('a1', 'wb').writelines(txt_a)
652
1213
        open('b1', 'wb').writelines(txt_b)
653
1214
 
654
 
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
655
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
656
 
        self.assertEquals(['--- a1 \n',
657
 
                           '+++ b1 \n',
 
1215
        unified_diff_files = patiencediff.unified_diff_files
 
1216
        psm = self._PatienceSequenceMatcher
 
1217
        self.assertEquals(['--- a1\n',
 
1218
                           '+++ b1\n',
658
1219
                           '@@ -1,3 +1,2 @@\n',
659
1220
                           ' hello there\n',
660
1221
                           '-world\n',
669
1230
        open('b2', 'wb').writelines(txt_b)
670
1231
 
671
1232
        # This is the result with LongestCommonSubstring matching
672
 
        self.assertEquals(['--- a2 \n',
673
 
                           '+++ b2 \n',
 
1233
        self.assertEquals(['--- a2\n',
 
1234
                           '+++ b2\n',
674
1235
                           '@@ -1,6 +1,11 @@\n',
675
1236
                           ' a\n',
676
1237
                           ' b\n',
686
1247
                          , list(unified_diff_files('a2', 'b2')))
687
1248
 
688
1249
        # And the patience diff
689
 
        self.assertEquals(['--- a2 \n',
690
 
                           '+++ b2 \n',
 
1250
        self.assertEquals(['--- a2\n',
 
1251
                           '+++ b2\n',
691
1252
                           '@@ -4,6 +4,11 @@\n',
692
1253
                           ' d\n',
693
1254
                           ' e\n',
703
1264
                          ]
704
1265
                          , list(unified_diff_files('a2', 'b2',
705
1266
                                 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)