← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

merge bzr.dev

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 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
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 errno
19
20
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, EncodingAdapter
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')
 
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.osutils as osutils
 
26
import bzrlib.patiencediff
 
27
from bzrlib.tests import (TestCase, TestCaseWithTransport,
 
28
                          TestCaseInTempDir, TestSkipped)
59
29
 
60
30
 
61
31
def udiff_lines(old, new, allow_binary=False):
62
32
    output = StringIO()
63
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
33
    internal_diff('old', old, 'new', new, output, allow_binary)
64
34
    output.seek(0, 0)
65
35
    return output.readlines()
66
36
 
70
40
        # StringIO has no fileno, so it tests a different codepath
71
41
        output = StringIO()
72
42
    else:
73
 
        output = tempfile.TemporaryFile()
 
43
        output = TemporaryFile()
74
44
    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')
 
45
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
46
    except NoDiff:
 
47
        raise TestSkipped('external "diff" not present to test')
78
48
    output.seek(0, 0)
79
49
    lines = output.readlines()
80
50
    output.close()
81
51
    return lines
82
52
 
83
53
 
84
 
class TestDiff(tests.TestCase):
 
54
class TestDiff(TestCase):
85
55
 
86
56
    def test_add_nl(self):
87
57
        """diff generates a valid diff for patches that add a newline"""
123
93
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
124
94
 
125
95
    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)
 
96
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
97
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
98
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
99
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
132
100
 
133
101
    def test_external_diff(self):
134
102
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
144
112
        self.check_patch(lines)
145
113
 
146
114
    def test_external_diff_binary_lang_c(self):
 
115
        old_env = {}
147
116
        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'])
 
117
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
118
        try:
 
119
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
120
            # Older versions of diffutils say "Binary files", newer
 
121
            # versions just say "Files".
 
122
            self.assertContainsRe(lines[0],
 
123
                                  '(Binary f|F)iles old and new differ\n')
 
124
            self.assertEquals(lines[1:], ['\n'])
 
125
        finally:
 
126
            for lang, old_val in old_env.iteritems():
 
127
                osutils.set_or_unset_env(lang, old_val)
154
128
 
155
129
    def test_no_external_diff(self):
156
130
        """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'])
163
 
 
 
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
        
164
141
    def test_internal_diff_default(self):
165
142
        # Default internal diff encoding is utf8
166
143
        output = StringIO()
167
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
168
 
                           u'new_\xe5', ['new_text\n'], output)
 
144
        internal_diff(u'old_\xb5', ['old_text\n'],
 
145
                    u'new_\xe5', ['new_text\n'], output)
169
146
        lines = output.getvalue().splitlines(True)
170
147
        self.check_patch(lines)
171
148
        self.assertEquals(['--- old_\xc2\xb5\n',
179
156
 
180
157
    def test_internal_diff_utf8(self):
181
158
        output = StringIO()
182
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
183
 
                           u'new_\xe5', ['new_text\n'], output,
184
 
                           path_encoding='utf8')
 
159
        internal_diff(u'old_\xb5', ['old_text\n'],
 
160
                    u'new_\xe5', ['new_text\n'], output,
 
161
                    path_encoding='utf8')
185
162
        lines = output.getvalue().splitlines(True)
186
163
        self.check_patch(lines)
187
164
        self.assertEquals(['--- old_\xc2\xb5\n',
195
172
 
196
173
    def test_internal_diff_iso_8859_1(self):
197
174
        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')
 
175
        internal_diff(u'old_\xb5', ['old_text\n'],
 
176
                    u'new_\xe5', ['new_text\n'], output,
 
177
                    path_encoding='iso-8859-1')
201
178
        lines = output.getvalue().splitlines(True)
202
179
        self.check_patch(lines)
203
180
        self.assertEquals(['--- old_\xb5\n',
209
186
                          ]
210
187
                          , lines)
211
188
 
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
189
    def test_internal_diff_returns_bytes(self):
225
190
        import StringIO
226
191
        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,
 
192
        internal_diff(u'old_\xb5', ['old_text\n'],
 
193
                    u'new_\xe5', ['new_text\n'], output)
 
194
        self.failUnless(isinstance(output.getvalue(), str),
230
195
            'internal_diff should return bytestrings')
231
196
 
232
197
 
233
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
198
class TestDiffFiles(TestCaseInTempDir):
234
199
 
235
200
    def test_external_diff_binary(self):
236
201
        """The output when using external diff should use diff's i18n error"""
249
214
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
250
215
 
251
216
 
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):
 
217
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
218
    """Has a helper for running show_diff_trees"""
 
219
 
 
220
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
221
        output = StringIO()
 
222
        if working_tree is not None:
 
223
            extra_trees = (working_tree,)
 
224
        else:
 
225
            extra_trees = ()
 
226
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
227
                        extra_trees=extra_trees, old_label='old/',
 
228
                        new_label='new/')
 
229
        return output.getvalue()
 
230
 
 
231
 
 
232
class TestDiffDates(TestShowDiffTreesHelper):
266
233
 
267
234
    def setUp(self):
268
235
        super(TestDiffDates, self).setUp()
303
270
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
304
271
 
305
272
    def test_diff_rev_tree_working_tree(self):
306
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
273
        output = self.get_diff(self.wt.basis_tree(), self.wt)
307
274
        # note that the date for old/file1 is from rev 2 rather than from
308
275
        # the basis revision (rev 4)
309
276
        self.assertEqualDiff(output, '''\
319
286
    def test_diff_rev_tree_rev_tree(self):
320
287
        tree1 = self.b.repository.revision_tree('rev-2')
321
288
        tree2 = self.b.repository.revision_tree('rev-3')
322
 
        output = get_diff_as_string(tree1, tree2)
 
289
        output = self.get_diff(tree1, tree2)
323
290
        self.assertEqualDiff(output, '''\
324
291
=== modified file 'file2'
325
292
--- old/file2\t2006-04-01 00:00:00 +0000
329
296
+file2 contents at rev 3
330
297
 
331
298
''')
332
 
 
 
299
        
333
300
    def test_diff_add_files(self):
334
 
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
 
301
        tree1 = self.b.repository.revision_tree(None)
335
302
        tree2 = self.b.repository.revision_tree('rev-1')
336
 
        output = get_diff_as_string(tree1, tree2)
 
303
        output = self.get_diff(tree1, tree2)
337
304
        # the files have the epoch time stamp for the tree in which
338
305
        # they don't exist.
339
306
        self.assertEqualDiff(output, '''\
354
321
    def test_diff_remove_files(self):
355
322
        tree1 = self.b.repository.revision_tree('rev-3')
356
323
        tree2 = self.b.repository.revision_tree('rev-4')
357
 
        output = get_diff_as_string(tree1, tree2)
 
324
        output = self.get_diff(tree1, tree2)
358
325
        # the file has the epoch time stamp for the tree in which
359
326
        # it doesn't exist.
360
327
        self.assertEqualDiff(output, '''\
371
338
        self.wt.rename_one('file1', 'file1b')
372
339
        old_tree = self.b.repository.revision_tree('rev-1')
373
340
        new_tree = self.b.repository.revision_tree('rev-4')
374
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
 
341
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
375
342
                            working_tree=self.wt)
376
343
        self.assertContainsRe(out, 'file1\t')
377
344
 
383
350
        self.wt.rename_one('file1', 'dir1/file1')
384
351
        old_tree = self.b.repository.revision_tree('rev-1')
385
352
        new_tree = self.b.repository.revision_tree('rev-4')
386
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
 
353
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
387
354
                            working_tree=self.wt)
388
355
        self.assertContainsRe(out, 'file1\t')
389
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
 
356
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
390
357
                            working_tree=self.wt)
391
358
        self.assertNotContainsRe(out, 'file1\t')
392
359
 
393
360
 
394
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
361
 
 
362
class TestShowDiffTrees(TestShowDiffTreesHelper):
395
363
    """Direct tests for show_diff_trees"""
396
364
 
397
365
    def test_modified_file(self):
402
370
        tree.commit('one', rev_id='rev-1')
403
371
 
404
372
        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')
 
373
        diff = self.get_diff(tree.basis_tree(), tree)
 
374
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
375
        self.assertContainsRe(diff, '--- old/file\t')
 
376
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
377
        self.assertContainsRe(diff, '-contents\n'
 
378
                                    '\\+new contents\n')
411
379
 
412
380
    def test_modified_file_in_renamed_dir(self):
413
381
        """Test when a file is modified in a renamed directory."""
419
387
 
420
388
        tree.rename_one('dir', 'other')
421
389
        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")
 
390
        diff = self.get_diff(tree.basis_tree(), tree)
 
391
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
392
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
425
393
        # XXX: This is technically incorrect, because it used to be at another
426
394
        # 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')
 
395
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
396
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
397
        self.assertContainsRe(diff, '-contents\n'
 
398
                                    '\\+new contents\n')
431
399
 
432
400
    def test_renamed_directory(self):
433
401
        """Test when only a directory is only renamed."""
438
406
        tree.commit('one', rev_id='rev-1')
439
407
 
440
408
        tree.rename_one('dir', 'newdir')
441
 
        d = get_diff_as_string(tree.basis_tree(), tree)
 
409
        diff = self.get_diff(tree.basis_tree(), tree)
442
410
        # Renaming a directory should be a single "you renamed this dir" even
443
411
        # when there are files inside.
444
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
412
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
445
413
 
446
414
    def test_renamed_file(self):
447
415
        """Test when a file is only renamed."""
451
419
        tree.commit('one', rev_id='rev-1')
452
420
 
453
421
        tree.rename_one('file', 'newname')
454
 
        d = get_diff_as_string(tree.basis_tree(), tree)
455
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
422
        diff = self.get_diff(tree.basis_tree(), tree)
 
423
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
456
424
        # We shouldn't have a --- or +++ line, because there is no content
457
425
        # change
458
 
        self.assertNotContainsRe(d, '---')
 
426
        self.assertNotContainsRe(diff, '---')
459
427
 
460
428
    def test_renamed_and_modified_file(self):
461
429
        """Test when a file is only renamed."""
466
434
 
467
435
        tree.rename_one('file', 'newname')
468
436
        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))
 
437
        diff = self.get_diff(tree.basis_tree(), tree)
 
438
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
439
        self.assertContainsRe(diff, '--- old/file\t')
 
440
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
441
        self.assertContainsRe(diff, '-contents\n'
 
442
                                    '\\+new contents\n')
 
443
 
 
444
 
 
445
class TestPatienceDiffLib(TestCase):
798
446
 
799
447
    def test_unique_lcs(self):
800
 
        unique_lcs = self._unique_lcs
 
448
        unique_lcs = bzrlib.patiencediff.unique_lcs
801
449
        self.assertEquals(unique_lcs('', ''), [])
802
 
        self.assertEquals(unique_lcs('', 'a'), [])
803
 
        self.assertEquals(unique_lcs('a', ''), [])
804
450
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
805
451
        self.assertEquals(unique_lcs('a', 'b'), [])
806
452
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
807
453
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
808
454
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
809
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
455
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
810
456
                                                         (3,3), (4,4)])
811
457
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
812
458
 
813
459
    def test_recurse_matches(self):
814
460
        def test_one(a, b, matches):
815
461
            test_matches = []
816
 
            self._recurse_matches(
817
 
                a, b, 0, 0, len(a), len(b), test_matches, 10)
 
462
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
 
463
                test_matches, 10)
818
464
            self.assertEquals(test_matches, matches)
819
465
 
820
466
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
821
467
                 [(0, 0), (2, 2), (4, 4)])
822
468
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
823
469
                 [(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
470
 
830
 
        # recurse_matches doesn't match non-unique
 
471
        # recurse_matches doesn't match non-unique 
831
472
        # lines surrounded by bogus text.
832
473
        # The update has been done in patiencediff.SequenceMatcher instead
833
474
 
837
478
        # This is what it currently gives:
838
479
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
839
480
 
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
481
    def test_matching_blocks(self):
 
482
        def chk_blocks(a, b, expected_blocks):
 
483
            # difflib always adds a signature of the total
 
484
            # length, with no matching entries at the end
 
485
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
486
            blocks = s.get_matching_blocks()
 
487
            self.assertEquals((len(a), len(b), 0), blocks[-1])
 
488
            self.assertEquals(expected_blocks, blocks[:-1])
 
489
 
855
490
        # 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
 
491
        chk_blocks('', '', [])
 
492
        chk_blocks([], [], [])
 
493
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
 
494
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
 
495
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
 
496
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
 
497
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
 
498
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
 
499
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
 
500
        # This may check too much, but it checks to see that 
868
501
        # a copied block stays attached to the previous section,
869
502
        # not the later one.
870
503
        # difflib would tend to grab the trailing longest match
871
504
        # which would make the diff not look right
872
 
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
873
 
                              [(0, 0, 6), (6, 11, 10)])
 
505
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
506
                   [(0, 0, 6), (6, 11, 10)])
874
507
 
875
508
        # make sure it supports passing in lists
876
 
        self.assertDiffBlocks(
 
509
        chk_blocks(
877
510
                   ['hello there\n',
878
511
                    'world\n',
879
512
                    'how are you today?\n'],
883
516
 
884
517
        # non unique lines surrounded by non-matching lines
885
518
        # won't be found
886
 
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
519
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
887
520
 
888
521
        # But they only need to be locally unique
889
 
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
522
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
890
523
 
891
524
        # non unique blocks won't be matched
892
 
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
525
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
893
526
 
894
527
        # but locally unique ones will
895
 
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
528
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
896
529
                                              (5,4,1), (7,5,2), (10,8,1)])
897
530
 
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)])
 
531
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
532
        chk_blocks('abbabbbb', 'cabbabbc', [])
 
533
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
925
534
 
926
535
    def test_opcodes(self):
927
536
        def chk_ops(a, b, expected_codes):
928
 
            s = self._PatienceSequenceMatcher(None, a, b)
 
537
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
929
538
            self.assertEquals(expected_codes, s.get_opcodes())
930
539
 
931
540
        chk_ops('', '', [])
932
541
        chk_ops([], [], [])
933
 
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
934
 
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
935
542
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
936
543
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
937
544
                                 ('replace', 3,4, 3,4)
970
577
                 ('delete', 1,2, 1,1),
971
578
                 ('equal',  2,3, 1,2),
972
579
                ])
973
 
        chk_ops('aBccDe', 'abccde',
 
580
        chk_ops('aBccDe', 'abccde', 
974
581
                [('equal',   0,1, 0,1),
975
582
                 ('replace', 1,5, 1,5),
976
583
                 ('equal',   5,6, 5,6),
977
584
                ])
978
 
        chk_ops('aBcDec', 'abcdec',
 
585
        chk_ops('aBcDec', 'abcdec', 
979
586
                [('equal',   0,1, 0,1),
980
587
                 ('replace', 1,2, 1,2),
981
588
                 ('equal',   2,3, 2,3),
982
589
                 ('replace', 3,4, 3,4),
983
590
                 ('equal',   4,6, 4,6),
984
591
                ])
985
 
        chk_ops('aBcdEcdFg', 'abcdecdfg',
 
592
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
986
593
                [('equal',   0,1, 0,1),
987
594
                 ('replace', 1,8, 1,8),
988
595
                 ('equal',   8,9, 8,9)
989
596
                ])
990
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
 
597
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
991
598
                [('equal',   0,1, 0,1),
992
599
                 ('replace', 1,2, 1,2),
993
600
                 ('equal',   2,4, 2,4),
999
606
                 ('equal',   10,11, 8,9)
1000
607
                ])
1001
608
 
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
609
    def test_multiple_ranges(self):
1040
610
        # There was an earlier bug where we used a bad set of ranges,
1041
611
        # 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)])
 
612
        def chk_blocks(a, b, expected_blocks):
 
613
            # difflib always adds a signature of the total
 
614
            # length, with no matching entries at the end
 
615
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
616
            blocks = s.get_matching_blocks()
 
617
            x = blocks.pop()
 
618
            self.assertEquals(x, (len(a), len(b), 0))
 
619
            self.assertEquals(expected_blocks, blocks)
 
620
 
 
621
        chk_blocks('abcdefghijklmnop'
 
622
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
 
623
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
 
624
 
 
625
        chk_blocks('ABCd efghIjk  L'
 
626
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
 
627
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
1049
628
 
1050
629
        # These are rot13 code snippets.
1051
 
        self.assertDiffBlocks('''\
 
630
        chk_blocks('''\
1052
631
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1053
632
    """
1054
633
    gnxrf_netf = ['svyr*']
1055
634
    gnxrf_bcgvbaf = ['ab-erphefr']
1056
 
 
 
635
  
1057
636
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1058
637
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1059
638
        vs vf_dhvrg():
1067
646
'''.splitlines(True), '''\
1068
647
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1069
648
 
1070
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
 
649
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
1071
650
    nqq gurz.
1072
651
    """
1073
652
    gnxrf_netf = ['svyr*']
1100
679
                 'how are you today?\n']
1101
680
        txt_b = ['hello there\n',
1102
681
                 'how are you today?\n']
1103
 
        unified_diff = patiencediff.unified_diff
1104
 
        psm = self._PatienceSequenceMatcher
1105
 
        self.assertEquals(['--- \n',
1106
 
                           '+++ \n',
 
682
        unified_diff = bzrlib.patiencediff.unified_diff
 
683
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
684
        self.assertEquals([ '---  \n',
 
685
                           '+++  \n',
1107
686
                           '@@ -1,3 +1,2 @@\n',
1108
687
                           ' hello there\n',
1109
688
                           '-world\n',
1114
693
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1115
694
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1116
695
        # This is the result with LongestCommonSubstring matching
1117
 
        self.assertEquals(['--- \n',
1118
 
                           '+++ \n',
 
696
        self.assertEquals(['---  \n',
 
697
                           '+++  \n',
1119
698
                           '@@ -1,6 +1,11 @@\n',
1120
699
                           ' a\n',
1121
700
                           ' b\n',
1130
709
                           ' f\n']
1131
710
                          , list(unified_diff(txt_a, txt_b)))
1132
711
        # And the patience diff
1133
 
        self.assertEquals(['--- \n',
1134
 
                           '+++ \n',
 
712
        self.assertEquals(['---  \n',
 
713
                           '+++  \n',
1135
714
                           '@@ -4,6 +4,11 @@\n',
1136
715
                           ' d\n',
1137
716
                           ' e\n',
1148
727
                          , list(unified_diff(txt_a, txt_b,
1149
728
                                 sequencematcher=psm)))
1150
729
 
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
 
730
 
 
731
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1205
732
 
1206
733
    def test_patience_unified_diff_files(self):
1207
734
        txt_a = ['hello there\n',
1212
739
        open('a1', 'wb').writelines(txt_a)
1213
740
        open('b1', 'wb').writelines(txt_b)
1214
741
 
1215
 
        unified_diff_files = patiencediff.unified_diff_files
1216
 
        psm = self._PatienceSequenceMatcher
1217
 
        self.assertEquals(['--- a1\n',
1218
 
                           '+++ b1\n',
 
742
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
 
743
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
744
        self.assertEquals(['--- a1 \n',
 
745
                           '+++ b1 \n',
1219
746
                           '@@ -1,3 +1,2 @@\n',
1220
747
                           ' hello there\n',
1221
748
                           '-world\n',
1230
757
        open('b2', 'wb').writelines(txt_b)
1231
758
 
1232
759
        # This is the result with LongestCommonSubstring matching
1233
 
        self.assertEquals(['--- a2\n',
1234
 
                           '+++ b2\n',
 
760
        self.assertEquals(['--- a2 \n',
 
761
                           '+++ b2 \n',
1235
762
                           '@@ -1,6 +1,11 @@\n',
1236
763
                           ' a\n',
1237
764
                           ' b\n',
1247
774
                          , list(unified_diff_files('a2', 'b2')))
1248
775
 
1249
776
        # And the patience diff
1250
 
        self.assertEquals(['--- a2\n',
1251
 
                           '+++ b2\n',
 
777
        self.assertEquals(['--- a2 \n',
 
778
                           '+++ b2 \n',
1252
779
                           '@@ -4,6 +4,11 @@\n',
1253
780
                           ' d\n',
1254
781
                           ' e\n',
1264
791
                          ]
1265
792
                          , list(unified_diff_files('a2', 'b2',
1266
793
                                 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 TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
1425
 
 
1426
 
    def test_encodable_filename(self):
1427
 
        # Just checks file path for external diff tool.
1428
 
        # We cannot change CPython's internal encoding used by os.exec*.
1429
 
        import sys
1430
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1431
 
                                    None, None, None)
1432
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1433
 
            encoding = scenario['encoding']
1434
 
            dirname  = scenario['info']['directory']
1435
 
            filename = scenario['info']['filename']
1436
 
 
1437
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1438
 
            relpath = dirname + u'/' + filename
1439
 
            fullpath = diffobj._safe_filename('safe', relpath)
1440
 
            self.assertEqual(
1441
 
                    fullpath,
1442
 
                    fullpath.encode(encoding).decode(encoding)
1443
 
                    )
1444
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1445
 
 
1446
 
    def test_unencodable_filename(self):
1447
 
        import sys
1448
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1449
 
                                    None, None, None)
1450
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1451
 
            encoding = scenario['encoding']
1452
 
            dirname  = scenario['info']['directory']
1453
 
            filename = scenario['info']['filename']
1454
 
 
1455
 
            if encoding == 'iso-8859-1':
1456
 
                encoding = 'iso-8859-2'
1457
 
            else:
1458
 
                encoding = 'iso-8859-1'
1459
 
 
1460
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1461
 
            relpath = dirname + u'/' + filename
1462
 
            fullpath = diffobj._safe_filename('safe', relpath)
1463
 
            self.assertEqual(
1464
 
                    fullpath,
1465
 
                    fullpath.encode(encoding).decode(encoding)
1466
 
                    )
1467
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1468
 
 
1469
 
 
1470
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1471
 
 
1472
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1473
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1474
 
        TestGetTreesAndBranchesToDiff.
1475
 
        """
1476
 
        return diff.get_trees_and_branches_to_diff_locked(
1477
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1478
 
 
1479
 
    def test_basic(self):
1480
 
        tree = self.make_branch_and_tree('tree')
1481
 
        (old_tree, new_tree,
1482
 
         old_branch, new_branch,
1483
 
         specific_files, extra_trees) = self.call_gtabtd(
1484
 
             ['tree'], None, None, None)
1485
 
 
1486
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1487
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1488
 
                         old_tree.get_revision_id())
1489
 
        self.assertEqual(tree.basedir, new_tree.basedir)
1490
 
        self.assertEqual(tree.branch.base, old_branch.base)
1491
 
        self.assertEqual(tree.branch.base, new_branch.base)
1492
 
        self.assertIs(None, specific_files)
1493
 
        self.assertIs(None, extra_trees)
1494
 
 
1495
 
    def test_with_rev_specs(self):
1496
 
        tree = self.make_branch_and_tree('tree')
1497
 
        self.build_tree_contents([('tree/file', 'oldcontent')])
1498
 
        tree.add('file', 'file-id')
1499
 
        tree.commit('old tree', timestamp=0, rev_id="old-id")
1500
 
        self.build_tree_contents([('tree/file', 'newcontent')])
1501
 
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1502
 
 
1503
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1504
 
                     revisionspec.RevisionSpec.from_string('2')]
1505
 
        (old_tree, new_tree,
1506
 
         old_branch, new_branch,
1507
 
         specific_files, extra_trees) = self.call_gtabtd(
1508
 
            ['tree'], revisions, None, None)
1509
 
 
1510
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1511
 
        self.assertEqual("old-id", old_tree.get_revision_id())
1512
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
1513
 
        self.assertEqual("new-id", new_tree.get_revision_id())
1514
 
        self.assertEqual(tree.branch.base, old_branch.base)
1515
 
        self.assertEqual(tree.branch.base, new_branch.base)
1516
 
        self.assertIs(None, specific_files)
1517
 
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1518
 
 
1519
 
 
1520
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1521
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1522
 
    deprecated get_trees_and_branches_to_diff function.
1523
 
    """
1524
 
 
1525
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1526
 
        return self.applyDeprecated(
1527
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1528
 
            path_list, revision_specs, old_url, new_url)