← 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: Tarmac
  • Author(s): Vincent Ladeuil, Patch Queue Manager, Jelmer Vernooij
  • Date: 2017-01-17 16:20:41 UTC
  • mfrom: (6619.1.2 trunk)
  • Revision ID: tarmac-20170117162041-oo62uk1qsmgc9j31
Merge 2.7 into trunk including fixes for bugs #1622039, #1644003, #1579093 and #1645017. [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2014, 2016, 2017 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., 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 tempfile
 
21
 
 
22
from bzrlib import (
 
23
    diff,
 
24
    errors,
 
25
    osutils,
 
26
    patiencediff,
 
27
    _patiencediff_py,
 
28
    revision as _mod_revision,
 
29
    revisionspec,
 
30
    revisiontree,
 
31
    tests,
 
32
    transform,
 
33
    )
 
34
from bzrlib.tests import (
 
35
    features,
 
36
    EncodingAdapter,
 
37
)
 
38
from bzrlib.tests.blackbox.test_diff import subst_dates
 
39
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
40
 
 
41
 
 
42
load_tests = load_tests_apply_scenarios
28
43
 
29
44
 
30
45
def udiff_lines(old, new, allow_binary=False):
31
46
    output = StringIO()
32
 
    internal_diff('old', old, 'new', new, output, allow_binary)
 
47
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
33
48
    output.seek(0, 0)
34
49
    return output.readlines()
35
50
 
39
54
        # StringIO has no fileno, so it tests a different codepath
40
55
        output = StringIO()
41
56
    else:
42
 
        output = TemporaryFile()
 
57
        output = tempfile.TemporaryFile()
43
58
    try:
44
 
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
45
 
    except NoDiff:
46
 
        raise TestSkipped('external "diff" not present to test')
 
59
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
60
    except errors.NoDiff:
 
61
        raise tests.TestSkipped('external "diff" not present to test')
47
62
    output.seek(0, 0)
48
63
    lines = output.readlines()
49
64
    output.close()
50
65
    return lines
51
66
 
52
67
 
53
 
class TestDiff(TestCase):
 
68
class TestDiffOptions(tests.TestCase):
 
69
 
 
70
    def test_unified_added(self):
 
71
        """Check for default style '-u' only if no other style specified
 
72
        in 'diff-options'.
 
73
        """
 
74
        # Verify that style defaults to unified, id est '-u' appended
 
75
        # to option list, in the absence of an alternative style.
 
76
        self.assertEqual(['-a', '-u'], diff.default_style_unified(['-a']))
 
77
 
 
78
 
 
79
class TestDiffOptionsScenarios(tests.TestCase):
 
80
 
 
81
    scenarios = [(s, dict(style=s)) for s in diff.style_option_list]
 
82
    style = None # Set by load_tests_apply_scenarios from scenarios
 
83
 
 
84
    def test_unified_not_added(self):
 
85
        # Verify that for all valid style options, '-u' is not
 
86
        # appended to option list.
 
87
        ret_opts = diff.default_style_unified(diff_opts=["%s" % (self.style,)])
 
88
        self.assertEqual(["%s" % (self.style,)], ret_opts)
 
89
 
 
90
 
 
91
class TestDiff(tests.TestCase):
54
92
 
55
93
    def test_add_nl(self):
56
94
        """diff generates a valid diff for patches that add a newline"""
57
95
        lines = udiff_lines(['boo'], ['boo\n'])
58
96
        self.check_patch(lines)
59
 
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
 
97
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
60
98
            ## "expected no-nl, got %r" % lines[4]
61
99
 
62
100
    def test_add_nl_2(self):
65
103
        """
66
104
        lines = udiff_lines(['boo'], ['goo\n'])
67
105
        self.check_patch(lines)
68
 
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
 
106
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
69
107
            ## "expected no-nl, got %r" % lines[4]
70
108
 
71
109
    def test_remove_nl(self):
74
112
        """
75
113
        lines = udiff_lines(['boo\n'], ['boo'])
76
114
        self.check_patch(lines)
77
 
        self.assertEquals(lines[5], '\\ No newline at end of file\n')
 
115
        self.assertEqual(lines[5], '\\ No newline at end of file\n')
78
116
            ## "expected no-nl, got %r" % lines[5]
79
117
 
80
118
    def check_patch(self, lines):
81
 
        self.assert_(len(lines) > 1)
 
119
        self.assertTrue(len(lines) > 1)
82
120
            ## "Not enough lines for a file header for patch:\n%s" % "".join(lines)
83
 
        self.assert_(lines[0].startswith ('---'))
 
121
        self.assertTrue(lines[0].startswith ('---'))
84
122
            ## 'No orig line for patch:\n%s' % "".join(lines)
85
 
        self.assert_(lines[1].startswith ('+++'))
 
123
        self.assertTrue(lines[1].startswith ('+++'))
86
124
            ## 'No mod line for patch:\n%s' % "".join(lines)
87
 
        self.assert_(len(lines) > 2)
 
125
        self.assertTrue(len(lines) > 2)
88
126
            ## "No hunks for patch:\n%s" % "".join(lines)
89
 
        self.assert_(lines[2].startswith('@@'))
 
127
        self.assertTrue(lines[2].startswith('@@'))
90
128
            ## "No hunk header for patch:\n%s" % "".join(lines)
91
 
        self.assert_('@@' in lines[2][2:])
 
129
        self.assertTrue('@@' in lines[2][2:])
92
130
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
93
131
 
94
132
    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)
 
133
        empty = []
 
134
        uni_lines = [1023 * 'a' + '\x00']
 
135
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
 
136
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
 
137
        udiff_lines(uni_lines , empty, allow_binary=True)
 
138
        udiff_lines(empty, uni_lines, allow_binary=True)
99
139
 
100
140
    def test_external_diff(self):
101
141
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
111
151
        self.check_patch(lines)
112
152
 
113
153
    def test_external_diff_binary_lang_c(self):
114
 
        orig_lang = os.environ.get('LANG')
115
 
        orig_lc_all = os.environ.get('LC_ALL')
116
 
        try:
117
 
            os.environ['LANG'] = 'C'
118
 
            os.environ['LC_ALL'] = 'C'
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 name, value in [('LANG', orig_lang), ('LC_ALL', orig_lc_all)]:
127
 
                if value is None:
128
 
                    del os.environ[name]
129
 
                else:
130
 
                    os.environ[name] = value
 
154
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
 
155
            self.overrideEnv(lang, 'C')
 
156
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
157
        # Older versions of diffutils say "Binary files", newer
 
158
        # versions just say "Files".
 
159
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
 
160
        self.assertEqual(lines[1:], ['\n'])
131
161
 
132
162
    def test_no_external_diff(self):
133
163
        """Check that NoDiff is raised when diff is not available"""
134
 
        # Use os.environ['PATH'] to make sure no 'diff' command is available
135
 
        orig_path = os.environ['PATH']
136
 
        try:
137
 
            os.environ['PATH'] = ''
138
 
            self.assertRaises(NoDiff, external_diff,
139
 
                              'old', ['boo\n'], 'new', ['goo\n'],
140
 
                              StringIO(), diff_opts=['-u'])
141
 
        finally:
142
 
            os.environ['PATH'] = orig_path
143
 
        
 
164
        # Make sure no 'diff' command is available
 
165
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
 
166
        self.overrideEnv('PATH', '')
 
167
        self.assertRaises(errors.NoDiff, diff.external_diff,
 
168
                          'old', ['boo\n'], 'new', ['goo\n'],
 
169
                          StringIO(), diff_opts=['-u'])
 
170
 
144
171
    def test_internal_diff_default(self):
145
172
        # Default internal diff encoding is utf8
146
173
        output = StringIO()
147
 
        internal_diff(u'old_\xb5', ['old_text\n'],
148
 
                    u'new_\xe5', ['new_text\n'], output)
 
174
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
175
                           u'new_\xe5', ['new_text\n'], output)
149
176
        lines = output.getvalue().splitlines(True)
150
177
        self.check_patch(lines)
151
 
        self.assertEquals(['--- old_\xc2\xb5\n',
 
178
        self.assertEqual(['--- old_\xc2\xb5\n',
152
179
                           '+++ new_\xc3\xa5\n',
153
180
                           '@@ -1,1 +1,1 @@\n',
154
181
                           '-old_text\n',
159
186
 
160
187
    def test_internal_diff_utf8(self):
161
188
        output = StringIO()
162
 
        internal_diff(u'old_\xb5', ['old_text\n'],
163
 
                    u'new_\xe5', ['new_text\n'], output,
164
 
                    path_encoding='utf8')
 
189
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
190
                           u'new_\xe5', ['new_text\n'], output,
 
191
                           path_encoding='utf8')
165
192
        lines = output.getvalue().splitlines(True)
166
193
        self.check_patch(lines)
167
 
        self.assertEquals(['--- old_\xc2\xb5\n',
 
194
        self.assertEqual(['--- old_\xc2\xb5\n',
168
195
                           '+++ new_\xc3\xa5\n',
169
196
                           '@@ -1,1 +1,1 @@\n',
170
197
                           '-old_text\n',
175
202
 
176
203
    def test_internal_diff_iso_8859_1(self):
177
204
        output = StringIO()
178
 
        internal_diff(u'old_\xb5', ['old_text\n'],
179
 
                    u'new_\xe5', ['new_text\n'], output,
180
 
                    path_encoding='iso-8859-1')
 
205
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
206
                           u'new_\xe5', ['new_text\n'], output,
 
207
                           path_encoding='iso-8859-1')
181
208
        lines = output.getvalue().splitlines(True)
182
209
        self.check_patch(lines)
183
 
        self.assertEquals(['--- old_\xb5\n',
 
210
        self.assertEqual(['--- old_\xb5\n',
184
211
                           '+++ new_\xe5\n',
185
212
                           '@@ -1,1 +1,1 @@\n',
186
213
                           '-old_text\n',
189
216
                          ]
190
217
                          , lines)
191
218
 
 
219
    def test_internal_diff_no_content(self):
 
220
        output = StringIO()
 
221
        diff.internal_diff(u'old', [], u'new', [], output)
 
222
        self.assertEqual('', output.getvalue())
 
223
 
 
224
    def test_internal_diff_no_changes(self):
 
225
        output = StringIO()
 
226
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
 
227
                           u'new', ['text\n', 'contents\n'],
 
228
                           output)
 
229
        self.assertEqual('', output.getvalue())
 
230
 
192
231
    def test_internal_diff_returns_bytes(self):
193
232
        import StringIO
194
233
        output = StringIO.StringIO()
195
 
        internal_diff(u'old_\xb5', ['old_text\n'],
196
 
                    u'new_\xe5', ['new_text\n'], output)
197
 
        self.failUnless(isinstance(output.getvalue(), str),
 
234
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
235
                            u'new_\xe5', ['new_text\n'], output)
 
236
        self.assertIsInstance(output.getvalue(), str,
198
237
            'internal_diff should return bytestrings')
199
238
 
200
 
 
201
 
class TestDiffFiles(TestCaseInTempDir):
 
239
    def test_internal_diff_default_context(self):
 
240
        output = StringIO()
 
241
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
242
                           'same_text\n','same_text\n','old_text\n'],
 
243
                           'new', ['same_text\n','same_text\n','same_text\n',
 
244
                           'same_text\n','same_text\n','new_text\n'], output)
 
245
        lines = output.getvalue().splitlines(True)
 
246
        self.check_patch(lines)
 
247
        self.assertEqual(['--- old\n',
 
248
                           '+++ new\n',
 
249
                           '@@ -3,4 +3,4 @@\n',
 
250
                           ' same_text\n',
 
251
                           ' same_text\n',
 
252
                           ' same_text\n',
 
253
                           '-old_text\n',
 
254
                           '+new_text\n',
 
255
                           '\n',
 
256
                          ]
 
257
                          , lines)
 
258
 
 
259
    def test_internal_diff_no_context(self):
 
260
        output = StringIO()
 
261
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
262
                           'same_text\n','same_text\n','old_text\n'],
 
263
                           'new', ['same_text\n','same_text\n','same_text\n',
 
264
                           'same_text\n','same_text\n','new_text\n'], output,
 
265
                           context_lines=0)
 
266
        lines = output.getvalue().splitlines(True)
 
267
        self.check_patch(lines)
 
268
        self.assertEqual(['--- old\n',
 
269
                           '+++ new\n',
 
270
                           '@@ -6,1 +6,1 @@\n',
 
271
                           '-old_text\n',
 
272
                           '+new_text\n',
 
273
                           '\n',
 
274
                          ]
 
275
                          , lines)
 
276
 
 
277
    def test_internal_diff_more_context(self):
 
278
        output = StringIO()
 
279
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
280
                           'same_text\n','same_text\n','old_text\n'],
 
281
                           'new', ['same_text\n','same_text\n','same_text\n',
 
282
                           'same_text\n','same_text\n','new_text\n'], output,
 
283
                           context_lines=4)
 
284
        lines = output.getvalue().splitlines(True)
 
285
        self.check_patch(lines)
 
286
        self.assertEqual(['--- old\n',
 
287
                           '+++ new\n',
 
288
                           '@@ -2,5 +2,5 @@\n',
 
289
                           ' same_text\n',
 
290
                           ' same_text\n',
 
291
                           ' same_text\n',
 
292
                           ' same_text\n',
 
293
                           '-old_text\n',
 
294
                           '+new_text\n',
 
295
                           '\n',
 
296
                          ]
 
297
                          , lines)
 
298
 
 
299
 
 
300
 
 
301
 
 
302
 
 
303
class TestDiffFiles(tests.TestCaseInTempDir):
202
304
 
203
305
    def test_external_diff_binary(self):
204
306
        """The output when using external diff should use diff's i18n error"""
206
308
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
207
309
 
208
310
        cmd = ['diff', '-u', '--binary', 'old', 'new']
209
 
        open('old', 'wb').write('\x00foobar\n')
210
 
        open('new', 'wb').write('foo\x00bar\n')
 
311
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
312
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
211
313
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
212
314
                                     stdin=subprocess.PIPE)
213
315
        out, err = pipe.communicate()
214
 
        # Diff returns '2' on Binary files.
215
 
        self.assertEqual(2, pipe.returncode)
216
316
        # We should output whatever diff tells us, plus a trailing newline
217
317
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
218
318
 
219
319
 
220
 
class TestDiffDates(TestCaseWithTransport):
 
320
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
 
321
    output = StringIO()
 
322
    if working_tree is not None:
 
323
        extra_trees = (working_tree,)
 
324
    else:
 
325
        extra_trees = ()
 
326
    diff.show_diff_trees(tree1, tree2, output,
 
327
        specific_files=specific_files,
 
328
        extra_trees=extra_trees, old_label='old/',
 
329
        new_label='new/')
 
330
    return output.getvalue()
 
331
 
 
332
 
 
333
class TestDiffDates(tests.TestCaseWithTransport):
221
334
 
222
335
    def setUp(self):
223
336
        super(TestDiffDates, self).setUp()
257
370
        # set the date stamps for files in the working tree to known values
258
371
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
259
372
 
260
 
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
261
 
        output = StringIO()
262
 
        if working_tree is not None:
263
 
            extra_trees = (working_tree,)
264
 
        else:
265
 
            extra_trees = ()
266
 
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
267
 
                        extra_trees=extra_trees, old_label='old/', 
268
 
                        new_label='new/')
269
 
        return output.getvalue()
270
 
 
271
373
    def test_diff_rev_tree_working_tree(self):
272
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
374
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
273
375
        # note that the date for old/file1 is from rev 2 rather than from
274
376
        # the basis revision (rev 4)
275
377
        self.assertEqualDiff(output, '''\
285
387
    def test_diff_rev_tree_rev_tree(self):
286
388
        tree1 = self.b.repository.revision_tree('rev-2')
287
389
        tree2 = self.b.repository.revision_tree('rev-3')
288
 
        output = self.get_diff(tree1, tree2)
 
390
        output = get_diff_as_string(tree1, tree2)
289
391
        self.assertEqualDiff(output, '''\
290
392
=== modified file 'file2'
291
393
--- old/file2\t2006-04-01 00:00:00 +0000
295
397
+file2 contents at rev 3
296
398
 
297
399
''')
298
 
        
 
400
 
299
401
    def test_diff_add_files(self):
300
 
        tree1 = self.b.repository.revision_tree(None)
 
402
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
301
403
        tree2 = self.b.repository.revision_tree('rev-1')
302
 
        output = self.get_diff(tree1, tree2)
 
404
        output = get_diff_as_string(tree1, tree2)
303
405
        # the files have the epoch time stamp for the tree in which
304
406
        # they don't exist.
305
407
        self.assertEqualDiff(output, '''\
320
422
    def test_diff_remove_files(self):
321
423
        tree1 = self.b.repository.revision_tree('rev-3')
322
424
        tree2 = self.b.repository.revision_tree('rev-4')
323
 
        output = self.get_diff(tree1, tree2)
 
425
        output = get_diff_as_string(tree1, tree2)
324
426
        # the file has the epoch time stamp for the tree in which
325
427
        # it doesn't exist.
326
428
        self.assertEqualDiff(output, '''\
337
439
        self.wt.rename_one('file1', 'file1b')
338
440
        old_tree = self.b.repository.revision_tree('rev-1')
339
441
        new_tree = self.b.repository.revision_tree('rev-4')
340
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
442
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
341
443
                            working_tree=self.wt)
342
444
        self.assertContainsRe(out, 'file1\t')
343
445
 
349
451
        self.wt.rename_one('file1', 'dir1/file1')
350
452
        old_tree = self.b.repository.revision_tree('rev-1')
351
453
        new_tree = self.b.repository.revision_tree('rev-4')
352
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
454
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
353
455
                            working_tree=self.wt)
354
456
        self.assertContainsRe(out, 'file1\t')
355
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
457
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
356
458
                            working_tree=self.wt)
357
459
        self.assertNotContainsRe(out, 'file1\t')
358
460
 
359
461
 
360
 
class TestPatienceDiffLib(TestCase):
 
462
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
463
    """Direct tests for show_diff_trees"""
 
464
 
 
465
    def test_modified_file(self):
 
466
        """Test when a file is modified."""
 
467
        tree = self.make_branch_and_tree('tree')
 
468
        self.build_tree_contents([('tree/file', 'contents\n')])
 
469
        tree.add(['file'], ['file-id'])
 
470
        tree.commit('one', rev_id='rev-1')
 
471
 
 
472
        self.build_tree_contents([('tree/file', 'new contents\n')])
 
473
        d = get_diff_as_string(tree.basis_tree(), tree)
 
474
        self.assertContainsRe(d, "=== modified file 'file'\n")
 
475
        self.assertContainsRe(d, '--- old/file\t')
 
476
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
 
477
        self.assertContainsRe(d, '-contents\n'
 
478
                                 '\\+new contents\n')
 
479
 
 
480
    def test_modified_file_in_renamed_dir(self):
 
481
        """Test when a file is modified in a renamed directory."""
 
482
        tree = self.make_branch_and_tree('tree')
 
483
        self.build_tree(['tree/dir/'])
 
484
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
485
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
486
        tree.commit('one', rev_id='rev-1')
 
487
 
 
488
        tree.rename_one('dir', 'other')
 
489
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
 
490
        d = get_diff_as_string(tree.basis_tree(), tree)
 
491
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
 
492
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
493
        # XXX: This is technically incorrect, because it used to be at another
 
494
        # location. What to do?
 
495
        self.assertContainsRe(d, '--- old/dir/file\t')
 
496
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
 
497
        self.assertContainsRe(d, '-contents\n'
 
498
                                 '\\+new contents\n')
 
499
 
 
500
    def test_renamed_directory(self):
 
501
        """Test when only a directory is only renamed."""
 
502
        tree = self.make_branch_and_tree('tree')
 
503
        self.build_tree(['tree/dir/'])
 
504
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
505
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
506
        tree.commit('one', rev_id='rev-1')
 
507
 
 
508
        tree.rename_one('dir', 'newdir')
 
509
        d = get_diff_as_string(tree.basis_tree(), tree)
 
510
        # Renaming a directory should be a single "you renamed this dir" even
 
511
        # when there are files inside.
 
512
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
513
 
 
514
    def test_renamed_file(self):
 
515
        """Test when a file is only renamed."""
 
516
        tree = self.make_branch_and_tree('tree')
 
517
        self.build_tree_contents([('tree/file', 'contents\n')])
 
518
        tree.add(['file'], ['file-id'])
 
519
        tree.commit('one', rev_id='rev-1')
 
520
 
 
521
        tree.rename_one('file', 'newname')
 
522
        d = get_diff_as_string(tree.basis_tree(), tree)
 
523
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
524
        # We shouldn't have a --- or +++ line, because there is no content
 
525
        # change
 
526
        self.assertNotContainsRe(d, '---')
 
527
 
 
528
    def test_renamed_and_modified_file(self):
 
529
        """Test when a file is only renamed."""
 
530
        tree = self.make_branch_and_tree('tree')
 
531
        self.build_tree_contents([('tree/file', 'contents\n')])
 
532
        tree.add(['file'], ['file-id'])
 
533
        tree.commit('one', rev_id='rev-1')
 
534
 
 
535
        tree.rename_one('file', 'newname')
 
536
        self.build_tree_contents([('tree/newname', 'new contents\n')])
 
537
        d = get_diff_as_string(tree.basis_tree(), tree)
 
538
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
539
        self.assertContainsRe(d, '--- old/file\t')
 
540
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
 
541
        self.assertContainsRe(d, '-contents\n'
 
542
                                 '\\+new contents\n')
 
543
 
 
544
 
 
545
    def test_internal_diff_exec_property(self):
 
546
        tree = self.make_branch_and_tree('tree')
 
547
 
 
548
        tt = transform.TreeTransform(tree)
 
549
        tt.new_file('a', tt.root, 'contents\n', 'a-id', True)
 
550
        tt.new_file('b', tt.root, 'contents\n', 'b-id', False)
 
551
        tt.new_file('c', tt.root, 'contents\n', 'c-id', True)
 
552
        tt.new_file('d', tt.root, 'contents\n', 'd-id', False)
 
553
        tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)
 
554
        tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)
 
555
        tt.apply()
 
556
        tree.commit('one', rev_id='rev-1')
 
557
 
 
558
        tt = transform.TreeTransform(tree)
 
559
        tt.set_executability(False, tt.trans_id_file_id('a-id'))
 
560
        tt.set_executability(True, tt.trans_id_file_id('b-id'))
 
561
        tt.set_executability(False, tt.trans_id_file_id('c-id'))
 
562
        tt.set_executability(True, tt.trans_id_file_id('d-id'))
 
563
        tt.apply()
 
564
        tree.rename_one('c', 'new-c')
 
565
        tree.rename_one('d', 'new-d')
 
566
 
 
567
        d = get_diff_as_string(tree.basis_tree(), tree)
 
568
 
 
569
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
 
570
                                  ".*\+x to -x.*\)")
 
571
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
 
572
                                  ".*-x to \+x.*\)")
 
573
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
 
574
                                  ".*\+x to -x.*\)")
 
575
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
 
576
                                  ".*-x to \+x.*\)")
 
577
        self.assertNotContainsRe(d, r"file 'e'")
 
578
        self.assertNotContainsRe(d, r"file 'f'")
 
579
 
 
580
    def test_binary_unicode_filenames(self):
 
581
        """Test that contents of files are *not* encoded in UTF-8 when there
 
582
        is a binary file in the diff.
 
583
        """
 
584
        # See https://bugs.launchpad.net/bugs/110092.
 
585
        self.requireFeature(features.UnicodeFilenameFeature)
 
586
 
 
587
        # This bug isn't triggered with cStringIO.
 
588
        from StringIO import StringIO
 
589
        tree = self.make_branch_and_tree('tree')
 
590
        alpha, omega = u'\u03b1', u'\u03c9'
 
591
        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')
 
592
        self.build_tree_contents(
 
593
            [('tree/' + alpha, chr(0)),
 
594
             ('tree/' + omega,
 
595
              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])
 
596
        tree.add([alpha], ['file-id'])
 
597
        tree.add([omega], ['file-id-2'])
 
598
        diff_content = StringIO()
 
599
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
 
600
        d = diff_content.getvalue()
 
601
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
 
602
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
 
603
                              % (alpha_utf8, alpha_utf8))
 
604
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
 
605
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
 
606
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
607
 
 
608
    def test_unicode_filename(self):
 
609
        """Test when the filename are unicode."""
 
610
        self.requireFeature(features.UnicodeFilenameFeature)
 
611
 
 
612
        alpha, omega = u'\u03b1', u'\u03c9'
 
613
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
 
614
 
 
615
        tree = self.make_branch_and_tree('tree')
 
616
        self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])
 
617
        tree.add(['ren_'+alpha], ['file-id-2'])
 
618
        self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])
 
619
        tree.add(['del_'+alpha], ['file-id-3'])
 
620
        self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])
 
621
        tree.add(['mod_'+alpha], ['file-id-4'])
 
622
 
 
623
        tree.commit('one', rev_id='rev-1')
 
624
 
 
625
        tree.rename_one('ren_'+alpha, 'ren_'+omega)
 
626
        tree.remove('del_'+alpha)
 
627
        self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])
 
628
        tree.add(['add_'+alpha], ['file-id'])
 
629
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
 
630
 
 
631
        d = get_diff_as_string(tree.basis_tree(), tree)
 
632
        self.assertContainsRe(d,
 
633
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
 
634
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
 
635
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
 
636
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
 
637
 
 
638
    def test_unicode_filename_path_encoding(self):
 
639
        """Test for bug #382699: unicode filenames on Windows should be shown
 
640
        in user encoding.
 
641
        """
 
642
        self.requireFeature(features.UnicodeFilenameFeature)
 
643
        # The word 'test' in Russian
 
644
        _russian_test = u'\u0422\u0435\u0441\u0442'
 
645
        directory = _russian_test + u'/'
 
646
        test_txt = _russian_test + u'.txt'
 
647
        u1234 = u'\u1234.txt'
 
648
 
 
649
        tree = self.make_branch_and_tree('.')
 
650
        self.build_tree_contents([
 
651
            (test_txt, 'foo\n'),
 
652
            (u1234, 'foo\n'),
 
653
            (directory, None),
 
654
            ])
 
655
        tree.add([test_txt, u1234, directory])
 
656
 
 
657
        sio = StringIO()
 
658
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
 
659
            path_encoding='cp1251')
 
660
 
 
661
        output = subst_dates(sio.getvalue())
 
662
        shouldbe = ('''\
 
663
=== added directory '%(directory)s'
 
664
=== added file '%(test_txt)s'
 
665
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
666
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
667
@@ -0,0 +1,1 @@
 
668
+foo
 
669
 
 
670
=== added file '?.txt'
 
671
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
672
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
673
@@ -0,0 +1,1 @@
 
674
+foo
 
675
 
 
676
''' % {'directory': _russian_test.encode('cp1251'),
 
677
       'test_txt': test_txt.encode('cp1251'),
 
678
      })
 
679
        self.assertEqualDiff(output, shouldbe)
 
680
 
 
681
 
 
682
class DiffWasIs(diff.DiffPath):
 
683
 
 
684
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
685
        self.to_file.write('was: ')
 
686
        self.to_file.write(self.old_tree.get_file(file_id).read())
 
687
        self.to_file.write('is: ')
 
688
        self.to_file.write(self.new_tree.get_file(file_id).read())
 
689
        pass
 
690
 
 
691
 
 
692
class TestDiffTree(tests.TestCaseWithTransport):
 
693
 
 
694
    def setUp(self):
 
695
        super(TestDiffTree, self).setUp()
 
696
        self.old_tree = self.make_branch_and_tree('old-tree')
 
697
        self.old_tree.lock_write()
 
698
        self.addCleanup(self.old_tree.unlock)
 
699
        self.new_tree = self.make_branch_and_tree('new-tree')
 
700
        self.new_tree.lock_write()
 
701
        self.addCleanup(self.new_tree.unlock)
 
702
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
703
 
 
704
    def test_diff_text(self):
 
705
        self.build_tree_contents([('old-tree/olddir/',),
 
706
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
707
        self.old_tree.add('olddir')
 
708
        self.old_tree.add('olddir/oldfile', 'file-id')
 
709
        self.build_tree_contents([('new-tree/newdir/',),
 
710
                                  ('new-tree/newdir/newfile', 'new\n')])
 
711
        self.new_tree.add('newdir')
 
712
        self.new_tree.add('newdir/newfile', 'file-id')
 
713
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
714
        differ.diff_text('file-id', None, 'old label', 'new label')
 
715
        self.assertEqual(
 
716
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
 
717
            differ.to_file.getvalue())
 
718
        differ.to_file.seek(0)
 
719
        differ.diff_text(None, 'file-id', 'old label', 'new label')
 
720
        self.assertEqual(
 
721
            '--- old label\n+++ new label\n@@ -0,0 +1,1 @@\n+new\n\n',
 
722
            differ.to_file.getvalue())
 
723
        differ.to_file.seek(0)
 
724
        differ.diff_text('file-id', 'file-id', 'old label', 'new label')
 
725
        self.assertEqual(
 
726
            '--- old label\n+++ new label\n@@ -1,1 +1,1 @@\n-old\n+new\n\n',
 
727
            differ.to_file.getvalue())
 
728
 
 
729
    def test_diff_deletion(self):
 
730
        self.build_tree_contents([('old-tree/file', 'contents'),
 
731
                                  ('new-tree/file', 'contents')])
 
732
        self.old_tree.add('file', 'file-id')
 
733
        self.new_tree.add('file', 'file-id')
 
734
        os.unlink('new-tree/file')
 
735
        self.differ.show_diff(None)
 
736
        self.assertContainsRe(self.differ.to_file.getvalue(), '-contents')
 
737
 
 
738
    def test_diff_creation(self):
 
739
        self.build_tree_contents([('old-tree/file', 'contents'),
 
740
                                  ('new-tree/file', 'contents')])
 
741
        self.old_tree.add('file', 'file-id')
 
742
        self.new_tree.add('file', 'file-id')
 
743
        os.unlink('old-tree/file')
 
744
        self.differ.show_diff(None)
 
745
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
 
746
 
 
747
    def test_diff_symlink(self):
 
748
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
749
        differ.diff_symlink('old target', None)
 
750
        self.assertEqual("=== target was 'old target'\n",
 
751
                         differ.to_file.getvalue())
 
752
 
 
753
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
754
        differ.diff_symlink(None, 'new target')
 
755
        self.assertEqual("=== target is 'new target'\n",
 
756
                         differ.to_file.getvalue())
 
757
 
 
758
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
759
        differ.diff_symlink('old target', 'new target')
 
760
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
 
761
                         differ.to_file.getvalue())
 
762
 
 
763
    def test_diff(self):
 
764
        self.build_tree_contents([('old-tree/olddir/',),
 
765
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
766
        self.old_tree.add('olddir')
 
767
        self.old_tree.add('olddir/oldfile', 'file-id')
 
768
        self.build_tree_contents([('new-tree/newdir/',),
 
769
                                  ('new-tree/newdir/newfile', 'new\n')])
 
770
        self.new_tree.add('newdir')
 
771
        self.new_tree.add('newdir/newfile', 'file-id')
 
772
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
773
        self.assertContainsRe(
 
774
            self.differ.to_file.getvalue(),
 
775
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
776
             ' \@\@\n-old\n\+new\n\n')
 
777
 
 
778
    def test_diff_kind_change(self):
 
779
        self.requireFeature(features.SymlinkFeature)
 
780
        self.build_tree_contents([('old-tree/olddir/',),
 
781
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
782
        self.old_tree.add('olddir')
 
783
        self.old_tree.add('olddir/oldfile', 'file-id')
 
784
        self.build_tree(['new-tree/newdir/'])
 
785
        os.symlink('new', 'new-tree/newdir/newfile')
 
786
        self.new_tree.add('newdir')
 
787
        self.new_tree.add('newdir/newfile', 'file-id')
 
788
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
789
        self.assertContainsRe(
 
790
            self.differ.to_file.getvalue(),
 
791
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
 
792
             ' \@\@\n-old\n\n')
 
793
        self.assertContainsRe(self.differ.to_file.getvalue(),
 
794
                              "=== target is u'new'\n")
 
795
 
 
796
    def test_diff_directory(self):
 
797
        self.build_tree(['new-tree/new-dir/'])
 
798
        self.new_tree.add('new-dir', 'new-dir-id')
 
799
        self.differ.diff('new-dir-id', None, 'new-dir')
 
800
        self.assertEqual(self.differ.to_file.getvalue(), '')
 
801
 
 
802
    def create_old_new(self):
 
803
        self.build_tree_contents([('old-tree/olddir/',),
 
804
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
805
        self.old_tree.add('olddir')
 
806
        self.old_tree.add('olddir/oldfile', 'file-id')
 
807
        self.build_tree_contents([('new-tree/newdir/',),
 
808
                                  ('new-tree/newdir/newfile', 'new\n')])
 
809
        self.new_tree.add('newdir')
 
810
        self.new_tree.add('newdir/newfile', 'file-id')
 
811
 
 
812
    def test_register_diff(self):
 
813
        self.create_old_new()
 
814
        old_diff_factories = diff.DiffTree.diff_factories
 
815
        diff.DiffTree.diff_factories=old_diff_factories[:]
 
816
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
817
        try:
 
818
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
819
        finally:
 
820
            diff.DiffTree.diff_factories = old_diff_factories
 
821
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
822
        self.assertNotContainsRe(
 
823
            differ.to_file.getvalue(),
 
824
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
825
             ' \@\@\n-old\n\+new\n\n')
 
826
        self.assertContainsRe(differ.to_file.getvalue(),
 
827
                              'was: old\nis: new\n')
 
828
 
 
829
    def test_extra_factories(self):
 
830
        self.create_old_new()
 
831
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
 
832
                               extra_factories=[DiffWasIs.from_diff_tree])
 
833
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
834
        self.assertNotContainsRe(
 
835
            differ.to_file.getvalue(),
 
836
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
837
             ' \@\@\n-old\n\+new\n\n')
 
838
        self.assertContainsRe(differ.to_file.getvalue(),
 
839
                              'was: old\nis: new\n')
 
840
 
 
841
    def test_alphabetical_order(self):
 
842
        self.build_tree(['new-tree/a-file'])
 
843
        self.new_tree.add('a-file')
 
844
        self.build_tree(['old-tree/b-file'])
 
845
        self.old_tree.add('b-file')
 
846
        self.differ.show_diff(None)
 
847
        self.assertContainsRe(self.differ.to_file.getvalue(),
 
848
            '.*a-file(.|\n)*b-file')
 
849
 
 
850
 
 
851
class TestPatienceDiffLib(tests.TestCase):
 
852
 
 
853
    def setUp(self):
 
854
        super(TestPatienceDiffLib, self).setUp()
 
855
        self._unique_lcs = _patiencediff_py.unique_lcs_py
 
856
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
857
        self._PatienceSequenceMatcher = \
 
858
            _patiencediff_py.PatienceSequenceMatcher_py
 
859
 
 
860
    def test_diff_unicode_string(self):
 
861
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
 
862
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
 
863
        sm = self._PatienceSequenceMatcher(None, a, b)
 
864
        mb = sm.get_matching_blocks()
 
865
        self.assertEqual(35, len(mb))
361
866
 
362
867
    def test_unique_lcs(self):
363
 
        unique_lcs = bzrlib.patiencediff.unique_lcs
364
 
        self.assertEquals(unique_lcs('', ''), [])
365
 
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
366
 
        self.assertEquals(unique_lcs('a', 'b'), [])
367
 
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
368
 
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
369
 
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
370
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
 
868
        unique_lcs = self._unique_lcs
 
869
        self.assertEqual(unique_lcs('', ''), [])
 
870
        self.assertEqual(unique_lcs('', 'a'), [])
 
871
        self.assertEqual(unique_lcs('a', ''), [])
 
872
        self.assertEqual(unique_lcs('a', 'a'), [(0,0)])
 
873
        self.assertEqual(unique_lcs('a', 'b'), [])
 
874
        self.assertEqual(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
 
875
        self.assertEqual(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
 
876
        self.assertEqual(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
 
877
        self.assertEqual(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
371
878
                                                         (3,3), (4,4)])
372
 
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
 
879
        self.assertEqual(unique_lcs('acbac', 'abc'), [(2,1)])
373
880
 
374
881
    def test_recurse_matches(self):
375
882
        def test_one(a, b, matches):
376
883
            test_matches = []
377
 
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
378
 
                test_matches, 10)
379
 
            self.assertEquals(test_matches, matches)
 
884
            self._recurse_matches(
 
885
                a, b, 0, 0, len(a), len(b), test_matches, 10)
 
886
            self.assertEqual(test_matches, matches)
380
887
 
381
888
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
382
889
                 [(0, 0), (2, 2), (4, 4)])
383
890
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
384
891
                 [(0, 0), (2, 1), (4, 2)])
 
892
        # Even though 'bc' is not unique globally, and is surrounded by
 
893
        # non-matching lines, we should still match, because they are locally
 
894
        # unique
 
895
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
 
896
                                          (4, 6), (5, 7), (6, 8)])
385
897
 
386
 
        # recurse_matches doesn't match non-unique 
 
898
        # recurse_matches doesn't match non-unique
387
899
        # lines surrounded by bogus text.
388
900
        # The update has been done in patiencediff.SequenceMatcher instead
389
901
 
393
905
        # This is what it currently gives:
394
906
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
395
907
 
 
908
    def assertDiffBlocks(self, a, b, expected_blocks):
 
909
        """Check that the sequence matcher returns the correct blocks.
 
910
 
 
911
        :param a: A sequence to match
 
912
        :param b: Another sequence to match
 
913
        :param expected_blocks: The expected output, not including the final
 
914
            matching block (len(a), len(b), 0)
 
915
        """
 
916
        matcher = self._PatienceSequenceMatcher(None, a, b)
 
917
        blocks = matcher.get_matching_blocks()
 
918
        last = blocks.pop()
 
919
        self.assertEqual((len(a), len(b), 0), last)
 
920
        self.assertEqual(expected_blocks, blocks)
 
921
 
396
922
    def test_matching_blocks(self):
397
 
        def chk_blocks(a, b, expected_blocks):
398
 
            # difflib always adds a signature of the total
399
 
            # length, with no matching entries at the end
400
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
401
 
            blocks = s.get_matching_blocks()
402
 
            self.assertEquals((len(a), len(b), 0), blocks[-1])
403
 
            self.assertEquals(expected_blocks, blocks[:-1])
404
 
 
405
923
        # Some basic matching tests
406
 
        chk_blocks('', '', [])
407
 
        chk_blocks([], [], [])
408
 
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
409
 
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
410
 
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
411
 
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
412
 
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
413
 
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
414
 
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
415
 
        # This may check too much, but it checks to see that 
 
924
        self.assertDiffBlocks('', '', [])
 
925
        self.assertDiffBlocks([], [], [])
 
926
        self.assertDiffBlocks('abc', '', [])
 
927
        self.assertDiffBlocks('', 'abc', [])
 
928
        self.assertDiffBlocks('abcd', 'abcd', [(0, 0, 4)])
 
929
        self.assertDiffBlocks('abcd', 'abce', [(0, 0, 3)])
 
930
        self.assertDiffBlocks('eabc', 'abce', [(1, 0, 3)])
 
931
        self.assertDiffBlocks('eabce', 'abce', [(1, 0, 4)])
 
932
        self.assertDiffBlocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
 
933
        self.assertDiffBlocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
 
934
        self.assertDiffBlocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
 
935
        # This may check too much, but it checks to see that
416
936
        # a copied block stays attached to the previous section,
417
937
        # not the later one.
418
938
        # difflib would tend to grab the trailing longest match
419
939
        # which would make the diff not look right
420
 
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
421
 
                   [(0, 0, 6), (6, 11, 10)])
 
940
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
941
                              [(0, 0, 6), (6, 11, 10)])
422
942
 
423
943
        # make sure it supports passing in lists
424
 
        chk_blocks(
 
944
        self.assertDiffBlocks(
425
945
                   ['hello there\n',
426
946
                    'world\n',
427
947
                    'how are you today?\n'],
431
951
 
432
952
        # non unique lines surrounded by non-matching lines
433
953
        # won't be found
434
 
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
954
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
435
955
 
436
956
        # But they only need to be locally unique
437
 
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
957
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
438
958
 
439
959
        # non unique blocks won't be matched
440
 
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
960
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
441
961
 
442
962
        # but locally unique ones will
443
 
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
963
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
444
964
                                              (5,4,1), (7,5,2), (10,8,1)])
445
965
 
446
 
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
447
 
        chk_blocks('abbabbbb', 'cabbabbc', [])
448
 
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
 
966
        self.assertDiffBlocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
967
        self.assertDiffBlocks('abbabbbb', 'cabbabbc', [])
 
968
        self.assertDiffBlocks('bbbbbbbb', 'cbbbbbbc', [])
 
969
 
 
970
    def test_matching_blocks_tuples(self):
 
971
        # Some basic matching tests
 
972
        self.assertDiffBlocks([], [], [])
 
973
        self.assertDiffBlocks([('a',), ('b',), ('c,')], [], [])
 
974
        self.assertDiffBlocks([], [('a',), ('b',), ('c,')], [])
 
975
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
 
976
                              [('a',), ('b',), ('c,')],
 
977
                              [(0, 0, 3)])
 
978
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
 
979
                              [('a',), ('b',), ('d,')],
 
980
                              [(0, 0, 2)])
 
981
        self.assertDiffBlocks([('d',), ('b',), ('c,')],
 
982
                              [('a',), ('b',), ('c,')],
 
983
                              [(1, 1, 2)])
 
984
        self.assertDiffBlocks([('d',), ('a',), ('b',), ('c,')],
 
985
                              [('a',), ('b',), ('c,')],
 
986
                              [(1, 0, 3)])
 
987
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
 
988
                              [('a', 'b'), ('c', 'X'), ('e', 'f')],
 
989
                              [(0, 0, 1), (2, 2, 1)])
 
990
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
 
991
                              [('a', 'b'), ('c', 'dX'), ('e', 'f')],
 
992
                              [(0, 0, 1), (2, 2, 1)])
449
993
 
450
994
    def test_opcodes(self):
451
995
        def chk_ops(a, b, expected_codes):
452
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
453
 
            self.assertEquals(expected_codes, s.get_opcodes())
 
996
            s = self._PatienceSequenceMatcher(None, a, b)
 
997
            self.assertEqual(expected_codes, s.get_opcodes())
454
998
 
455
999
        chk_ops('', '', [])
456
1000
        chk_ops([], [], [])
 
1001
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
 
1002
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
457
1003
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
458
1004
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
459
1005
                                 ('replace', 3,4, 3,4)
492
1038
                 ('delete', 1,2, 1,1),
493
1039
                 ('equal',  2,3, 1,2),
494
1040
                ])
495
 
        chk_ops('aBccDe', 'abccde', 
 
1041
        chk_ops('aBccDe', 'abccde',
496
1042
                [('equal',   0,1, 0,1),
497
1043
                 ('replace', 1,5, 1,5),
498
1044
                 ('equal',   5,6, 5,6),
499
1045
                ])
500
 
        chk_ops('aBcDec', 'abcdec', 
 
1046
        chk_ops('aBcDec', 'abcdec',
501
1047
                [('equal',   0,1, 0,1),
502
1048
                 ('replace', 1,2, 1,2),
503
1049
                 ('equal',   2,3, 2,3),
504
1050
                 ('replace', 3,4, 3,4),
505
1051
                 ('equal',   4,6, 4,6),
506
1052
                ])
507
 
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
 
1053
        chk_ops('aBcdEcdFg', 'abcdecdfg',
508
1054
                [('equal',   0,1, 0,1),
509
1055
                 ('replace', 1,8, 1,8),
510
1056
                 ('equal',   8,9, 8,9)
511
1057
                ])
512
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
1058
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
513
1059
                [('equal',   0,1, 0,1),
514
1060
                 ('replace', 1,2, 1,2),
515
1061
                 ('equal',   2,4, 2,4),
521
1067
                 ('equal',   10,11, 8,9)
522
1068
                ])
523
1069
 
 
1070
    def test_grouped_opcodes(self):
 
1071
        def chk_ops(a, b, expected_codes, n=3):
 
1072
            s = self._PatienceSequenceMatcher(None, a, b)
 
1073
            self.assertEqual(expected_codes, list(s.get_grouped_opcodes(n)))
 
1074
 
 
1075
        chk_ops('', '', [])
 
1076
        chk_ops([], [], [])
 
1077
        chk_ops('abc', '', [[('delete', 0,3, 0,0)]])
 
1078
        chk_ops('', 'abc', [[('insert', 0,0, 0,3)]])
 
1079
        chk_ops('abcd', 'abcd', [])
 
1080
        chk_ops('abcd', 'abce', [[('equal',   0,3, 0,3),
 
1081
                                  ('replace', 3,4, 3,4)
 
1082
                                 ]])
 
1083
        chk_ops('eabc', 'abce', [[('delete', 0,1, 0,0),
 
1084
                                 ('equal',  1,4, 0,3),
 
1085
                                 ('insert', 4,4, 3,4)
 
1086
                                ]])
 
1087
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
1088
                [[('equal',  3,6, 3,6),
 
1089
                  ('insert', 6,6, 6,11),
 
1090
                  ('equal',  6,9, 11,14)
 
1091
                  ]])
 
1092
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
1093
                [[('equal',  2,6, 2,6),
 
1094
                  ('insert', 6,6, 6,11),
 
1095
                  ('equal',  6,10, 11,15)
 
1096
                  ]], 4)
 
1097
        chk_ops('Xabcdef', 'abcdef',
 
1098
                [[('delete', 0,1, 0,0),
 
1099
                  ('equal',  1,4, 0,3)
 
1100
                  ]])
 
1101
        chk_ops('abcdef', 'abcdefX',
 
1102
                [[('equal',  3,6, 3,6),
 
1103
                  ('insert', 6,6, 6,7)
 
1104
                  ]])
 
1105
 
 
1106
 
524
1107
    def test_multiple_ranges(self):
525
1108
        # There was an earlier bug where we used a bad set of ranges,
526
1109
        # this triggers that specific bug, to make sure it doesn't regress
527
 
        def chk_blocks(a, b, expected_blocks):
528
 
            # difflib always adds a signature of the total
529
 
            # length, with no matching entries at the end
530
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
531
 
            blocks = s.get_matching_blocks()
532
 
            x = blocks.pop()
533
 
            self.assertEquals(x, (len(a), len(b), 0))
534
 
            self.assertEquals(expected_blocks, blocks)
535
 
 
536
 
        chk_blocks('abcdefghijklmnop'
537
 
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
538
 
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
539
 
 
540
 
        chk_blocks('ABCd efghIjk  L'
541
 
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
542
 
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
 
1110
        self.assertDiffBlocks('abcdefghijklmnop',
 
1111
                              'abcXghiYZQRSTUVWXYZijklmnop',
 
1112
                              [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
 
1113
 
 
1114
        self.assertDiffBlocks('ABCd efghIjk  L',
 
1115
                              'AxyzBCn mo pqrstuvwI1 2  L',
 
1116
                              [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
543
1117
 
544
1118
        # These are rot13 code snippets.
545
 
        chk_blocks('''\
 
1119
        self.assertDiffBlocks('''\
546
1120
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
547
1121
    """
548
1122
    gnxrf_netf = ['svyr*']
549
1123
    gnxrf_bcgvbaf = ['ab-erphefr']
550
 
  
 
1124
 
551
1125
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
552
1126
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
553
1127
        vs vf_dhvrg():
561
1135
'''.splitlines(True), '''\
562
1136
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
563
1137
 
564
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
 
1138
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
565
1139
    nqq gurz.
566
1140
    """
567
1141
    gnxrf_netf = ['svyr*']
594
1168
                 'how are you today?\n']
595
1169
        txt_b = ['hello there\n',
596
1170
                 'how are you today?\n']
597
 
        unified_diff = bzrlib.patiencediff.unified_diff
598
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
599
 
        self.assertEquals([ '---  \n',
600
 
                           '+++  \n',
 
1171
        unified_diff = patiencediff.unified_diff
 
1172
        psm = self._PatienceSequenceMatcher
 
1173
        self.assertEqual(['--- \n',
 
1174
                           '+++ \n',
601
1175
                           '@@ -1,3 +1,2 @@\n',
602
1176
                           ' hello there\n',
603
1177
                           '-world\n',
608
1182
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
609
1183
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
610
1184
        # This is the result with LongestCommonSubstring matching
611
 
        self.assertEquals(['---  \n',
612
 
                           '+++  \n',
 
1185
        self.assertEqual(['--- \n',
 
1186
                           '+++ \n',
613
1187
                           '@@ -1,6 +1,11 @@\n',
614
1188
                           ' a\n',
615
1189
                           ' b\n',
624
1198
                           ' f\n']
625
1199
                          , list(unified_diff(txt_a, txt_b)))
626
1200
        # And the patience diff
627
 
        self.assertEquals(['---  \n',
628
 
                           '+++  \n',
 
1201
        self.assertEqual(['--- \n',
 
1202
                           '+++ \n',
629
1203
                           '@@ -4,6 +4,11 @@\n',
630
1204
                           ' d\n',
631
1205
                           ' e\n',
642
1216
                          , list(unified_diff(txt_a, txt_b,
643
1217
                                 sequencematcher=psm)))
644
1218
 
645
 
 
646
 
class TestPatienceDiffLibFiles(TestCaseInTempDir):
 
1219
    def test_patience_unified_diff_with_dates(self):
 
1220
        txt_a = ['hello there\n',
 
1221
                 'world\n',
 
1222
                 'how are you today?\n']
 
1223
        txt_b = ['hello there\n',
 
1224
                 'how are you today?\n']
 
1225
        unified_diff = patiencediff.unified_diff
 
1226
        psm = self._PatienceSequenceMatcher
 
1227
        self.assertEqual(['--- a\t2008-08-08\n',
 
1228
                           '+++ b\t2008-09-09\n',
 
1229
                           '@@ -1,3 +1,2 @@\n',
 
1230
                           ' hello there\n',
 
1231
                           '-world\n',
 
1232
                           ' how are you today?\n'
 
1233
                          ]
 
1234
                          , list(unified_diff(txt_a, txt_b,
 
1235
                                 fromfile='a', tofile='b',
 
1236
                                 fromfiledate='2008-08-08',
 
1237
                                 tofiledate='2008-09-09',
 
1238
                                 sequencematcher=psm)))
 
1239
 
 
1240
 
 
1241
class TestPatienceDiffLib_c(TestPatienceDiffLib):
 
1242
 
 
1243
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1244
 
 
1245
    def setUp(self):
 
1246
        super(TestPatienceDiffLib_c, self).setUp()
 
1247
        from bzrlib import _patiencediff_c
 
1248
        self._unique_lcs = _patiencediff_c.unique_lcs_c
 
1249
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1250
        self._PatienceSequenceMatcher = \
 
1251
            _patiencediff_c.PatienceSequenceMatcher_c
 
1252
 
 
1253
    def test_unhashable(self):
 
1254
        """We should get a proper exception here."""
 
1255
        # We need to be able to hash items in the sequence, lists are
 
1256
        # unhashable, and thus cannot be diffed
 
1257
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1258
                                         None, [[]], [])
 
1259
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1260
                                         None, ['valid', []], [])
 
1261
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1262
                                         None, ['valid'], [[]])
 
1263
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1264
                                         None, ['valid'], ['valid', []])
 
1265
 
 
1266
 
 
1267
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1268
 
 
1269
    def setUp(self):
 
1270
        super(TestPatienceDiffLibFiles, self).setUp()
 
1271
        self._PatienceSequenceMatcher = \
 
1272
            _patiencediff_py.PatienceSequenceMatcher_py
647
1273
 
648
1274
    def test_patience_unified_diff_files(self):
649
1275
        txt_a = ['hello there\n',
651
1277
                 'how are you today?\n']
652
1278
        txt_b = ['hello there\n',
653
1279
                 'how are you today?\n']
654
 
        open('a1', 'wb').writelines(txt_a)
655
 
        open('b1', 'wb').writelines(txt_b)
 
1280
        with open('a1', 'wb') as f: f.writelines(txt_a)
 
1281
        with open('b1', 'wb') as f: f.writelines(txt_b)
656
1282
 
657
 
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
658
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
659
 
        self.assertEquals(['--- a1 \n',
660
 
                           '+++ b1 \n',
 
1283
        unified_diff_files = patiencediff.unified_diff_files
 
1284
        psm = self._PatienceSequenceMatcher
 
1285
        self.assertEqual(['--- a1\n',
 
1286
                           '+++ b1\n',
661
1287
                           '@@ -1,3 +1,2 @@\n',
662
1288
                           ' hello there\n',
663
1289
                           '-world\n',
668
1294
 
669
1295
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
670
1296
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
671
 
        open('a2', 'wb').writelines(txt_a)
672
 
        open('b2', 'wb').writelines(txt_b)
 
1297
        with open('a2', 'wb') as f: f.writelines(txt_a)
 
1298
        with open('b2', 'wb') as f: f.writelines(txt_b)
673
1299
 
674
1300
        # This is the result with LongestCommonSubstring matching
675
 
        self.assertEquals(['--- a2 \n',
676
 
                           '+++ b2 \n',
 
1301
        self.assertEqual(['--- a2\n',
 
1302
                           '+++ b2\n',
677
1303
                           '@@ -1,6 +1,11 @@\n',
678
1304
                           ' a\n',
679
1305
                           ' b\n',
689
1315
                          , list(unified_diff_files('a2', 'b2')))
690
1316
 
691
1317
        # And the patience diff
692
 
        self.assertEquals(['--- a2 \n',
693
 
                           '+++ b2 \n',
694
 
                           '@@ -4,6 +4,11 @@\n',
695
 
                           ' d\n',
696
 
                           ' e\n',
697
 
                           ' f\n',
698
 
                           '+x\n',
699
 
                           '+y\n',
700
 
                           '+d\n',
701
 
                           '+e\n',
702
 
                           '+f\n',
703
 
                           ' g\n',
704
 
                           ' h\n',
705
 
                           ' i\n',
706
 
                          ]
707
 
                          , list(unified_diff_files('a2', 'b2',
708
 
                                 sequencematcher=psm)))
 
1318
        self.assertEqual(['--- a2\n',
 
1319
                          '+++ b2\n',
 
1320
                          '@@ -4,6 +4,11 @@\n',
 
1321
                          ' d\n',
 
1322
                          ' e\n',
 
1323
                          ' f\n',
 
1324
                          '+x\n',
 
1325
                          '+y\n',
 
1326
                          '+d\n',
 
1327
                          '+e\n',
 
1328
                          '+f\n',
 
1329
                          ' g\n',
 
1330
                          ' h\n',
 
1331
                          ' i\n'],
 
1332
                         list(unified_diff_files('a2', 'b2',
 
1333
                                                 sequencematcher=psm)))
 
1334
 
 
1335
 
 
1336
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
 
1337
 
 
1338
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1339
 
 
1340
    def setUp(self):
 
1341
        super(TestPatienceDiffLibFiles_c, self).setUp()
 
1342
        from bzrlib import _patiencediff_c
 
1343
        self._PatienceSequenceMatcher = \
 
1344
            _patiencediff_c.PatienceSequenceMatcher_c
 
1345
 
 
1346
 
 
1347
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1348
 
 
1349
    def test_PatienceSequenceMatcher(self):
 
1350
        if features.compiled_patiencediff_feature.available():
 
1351
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
 
1352
            self.assertIs(PatienceSequenceMatcher_c,
 
1353
                          patiencediff.PatienceSequenceMatcher)
 
1354
        else:
 
1355
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
 
1356
            self.assertIs(PatienceSequenceMatcher_py,
 
1357
                          patiencediff.PatienceSequenceMatcher)
 
1358
 
 
1359
    def test_unique_lcs(self):
 
1360
        if features.compiled_patiencediff_feature.available():
 
1361
            from bzrlib._patiencediff_c import unique_lcs_c
 
1362
            self.assertIs(unique_lcs_c,
 
1363
                          patiencediff.unique_lcs)
 
1364
        else:
 
1365
            from bzrlib._patiencediff_py import unique_lcs_py
 
1366
            self.assertIs(unique_lcs_py,
 
1367
                          patiencediff.unique_lcs)
 
1368
 
 
1369
    def test_recurse_matches(self):
 
1370
        if features.compiled_patiencediff_feature.available():
 
1371
            from bzrlib._patiencediff_c import recurse_matches_c
 
1372
            self.assertIs(recurse_matches_c,
 
1373
                          patiencediff.recurse_matches)
 
1374
        else:
 
1375
            from bzrlib._patiencediff_py import recurse_matches_py
 
1376
            self.assertIs(recurse_matches_py,
 
1377
                          patiencediff.recurse_matches)
 
1378
 
 
1379
 
 
1380
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1381
 
 
1382
    def test_from_string(self):
 
1383
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1384
        self.addCleanup(diff_obj.finish)
 
1385
        self.assertEqual(['diff', '@old_path', '@new_path'],
 
1386
            diff_obj.command_template)
 
1387
 
 
1388
    def test_from_string_u5(self):
 
1389
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
 
1390
                                                 None, None, None)
 
1391
        self.addCleanup(diff_obj.finish)
 
1392
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
 
1393
                         diff_obj.command_template)
 
1394
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
 
1395
                         diff_obj._get_command('old-path', 'new-path'))
 
1396
 
 
1397
    def test_from_string_path_with_backslashes(self):
 
1398
        self.requireFeature(features.backslashdir_feature)
 
1399
        tool = 'C:\\Tools\\Diff.exe'
 
1400
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
 
1401
        self.addCleanup(diff_obj.finish)
 
1402
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
 
1403
                         diff_obj.command_template)
 
1404
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
 
1405
                         diff_obj._get_command('old-path', 'new-path'))
 
1406
 
 
1407
    def test_execute(self):
 
1408
        output = StringIO()
 
1409
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1410
                                      'print "@old_path @new_path"'],
 
1411
                                     None, None, output)
 
1412
        self.addCleanup(diff_obj.finish)
 
1413
        diff_obj._execute('old', 'new')
 
1414
        self.assertEqual(output.getvalue().rstrip(), 'old new')
 
1415
 
 
1416
    def test_execute_missing(self):
 
1417
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1418
                                     None, None, None)
 
1419
        self.addCleanup(diff_obj.finish)
 
1420
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
 
1421
                              'old', 'new')
 
1422
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
 
1423
                         ' on this machine', str(e))
 
1424
 
 
1425
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
 
1426
        self.requireFeature(features.AttribFeature)
 
1427
        output = StringIO()
 
1428
        tree = self.make_branch_and_tree('tree')
 
1429
        self.build_tree_contents([('tree/file', 'content')])
 
1430
        tree.add('file', 'file-id')
 
1431
        tree.commit('old tree')
 
1432
        tree.lock_read()
 
1433
        self.addCleanup(tree.unlock)
 
1434
        basis_tree = tree.basis_tree()
 
1435
        basis_tree.lock_read()
 
1436
        self.addCleanup(basis_tree.unlock)
 
1437
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1438
                                      'print "@old_path @new_path"'],
 
1439
                                     basis_tree, tree, output)
 
1440
        diff_obj._prepare_files('file-id', 'file', 'file')
 
1441
        # The old content should be readonly
 
1442
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
 
1443
                                    r'R.*old\\file$')
 
1444
        # The new content should use the tree object, not a 'new' file anymore
 
1445
        self.assertEndsWith(tree.basedir, 'work/tree')
 
1446
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
 
1447
 
 
1448
    def assertReadableByAttrib(self, cwd, relpath, regex):
 
1449
        proc = subprocess.Popen(['attrib', relpath],
 
1450
                                stdout=subprocess.PIPE,
 
1451
                                cwd=cwd)
 
1452
        (result, err) = proc.communicate()
 
1453
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
 
1454
 
 
1455
    def test_prepare_files(self):
 
1456
        output = StringIO()
 
1457
        tree = self.make_branch_and_tree('tree')
 
1458
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
 
1459
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
 
1460
        tree.add('oldname', 'file-id')
 
1461
        tree.add('oldname2', 'file2-id')
 
1462
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
 
1463
        tree.commit('old tree', timestamp=315532800)
 
1464
        tree.rename_one('oldname', 'newname')
 
1465
        tree.rename_one('oldname2', 'newname2')
 
1466
        self.build_tree_contents([('tree/newname', 'newcontent')])
 
1467
        self.build_tree_contents([('tree/newname2', 'newcontent2')])
 
1468
        old_tree = tree.basis_tree()
 
1469
        old_tree.lock_read()
 
1470
        self.addCleanup(old_tree.unlock)
 
1471
        tree.lock_read()
 
1472
        self.addCleanup(tree.unlock)
 
1473
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1474
                                      'print "@old_path @new_path"'],
 
1475
                                     old_tree, tree, output)
 
1476
        self.addCleanup(diff_obj.finish)
 
1477
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
 
1478
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
 
1479
                                                     'newname')
 
1480
        self.assertContainsRe(old_path, 'old/oldname$')
 
1481
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
 
1482
        self.assertContainsRe(new_path, 'tree/newname$')
 
1483
        self.assertFileEqual('oldcontent', old_path)
 
1484
        self.assertFileEqual('newcontent', new_path)
 
1485
        if osutils.host_os_dereferences_symlinks():
 
1486
            self.assertTrue(os.path.samefile('tree/newname', new_path))
 
1487
        # make sure we can create files with the same parent directories
 
1488
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
 
1489
 
 
1490
 
 
1491
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
 
1492
 
 
1493
    def test_encodable_filename(self):
 
1494
        # Just checks file path for external diff tool.
 
1495
        # We cannot change CPython's internal encoding used by os.exec*.
 
1496
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1497
                                    None, None, None)
 
1498
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1499
            encoding = scenario['encoding']
 
1500
            dirname = scenario['info']['directory']
 
1501
            filename = scenario['info']['filename']
 
1502
 
 
1503
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1504
            relpath = dirname + u'/' + filename
 
1505
            fullpath = diffobj._safe_filename('safe', relpath)
 
1506
            self.assertEqual(fullpath,
 
1507
                             fullpath.encode(encoding).decode(encoding))
 
1508
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
 
1509
 
 
1510
    def test_unencodable_filename(self):
 
1511
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1512
                                    None, None, None)
 
1513
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1514
            encoding = scenario['encoding']
 
1515
            dirname = scenario['info']['directory']
 
1516
            filename = scenario['info']['filename']
 
1517
 
 
1518
            if encoding == 'iso-8859-1':
 
1519
                encoding = 'iso-8859-2'
 
1520
            else:
 
1521
                encoding = 'iso-8859-1'
 
1522
 
 
1523
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1524
            relpath = dirname + u'/' + filename
 
1525
            fullpath = diffobj._safe_filename('safe', relpath)
 
1526
            self.assertEqual(fullpath,
 
1527
                             fullpath.encode(encoding).decode(encoding))
 
1528
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
 
1529
 
 
1530
 
 
1531
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
 
1532
 
 
1533
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
 
1534
        """Call get_trees_and_branches_to_diff_locked."""
 
1535
        return diff.get_trees_and_branches_to_diff_locked(
 
1536
            path_list, revision_specs, old_url, new_url, self.addCleanup)
 
1537
 
 
1538
    def test_basic(self):
 
1539
        tree = self.make_branch_and_tree('tree')
 
1540
        (old_tree, new_tree,
 
1541
         old_branch, new_branch,
 
1542
         specific_files, extra_trees) = self.call_gtabtd(
 
1543
             ['tree'], None, None, None)
 
1544
 
 
1545
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1546
        self.assertEqual(_mod_revision.NULL_REVISION,
 
1547
                         old_tree.get_revision_id())
 
1548
        self.assertEqual(tree.basedir, new_tree.basedir)
 
1549
        self.assertEqual(tree.branch.base, old_branch.base)
 
1550
        self.assertEqual(tree.branch.base, new_branch.base)
 
1551
        self.assertIs(None, specific_files)
 
1552
        self.assertIs(None, extra_trees)
 
1553
 
 
1554
    def test_with_rev_specs(self):
 
1555
        tree = self.make_branch_and_tree('tree')
 
1556
        self.build_tree_contents([('tree/file', 'oldcontent')])
 
1557
        tree.add('file', 'file-id')
 
1558
        tree.commit('old tree', timestamp=0, rev_id="old-id")
 
1559
        self.build_tree_contents([('tree/file', 'newcontent')])
 
1560
        tree.commit('new tree', timestamp=0, rev_id="new-id")
 
1561
 
 
1562
        revisions = [revisionspec.RevisionSpec.from_string('1'),
 
1563
                     revisionspec.RevisionSpec.from_string('2')]
 
1564
        (old_tree, new_tree,
 
1565
         old_branch, new_branch,
 
1566
         specific_files, extra_trees) = self.call_gtabtd(
 
1567
            ['tree'], revisions, None, None)
 
1568
 
 
1569
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1570
        self.assertEqual("old-id", old_tree.get_revision_id())
 
1571
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
 
1572
        self.assertEqual("new-id", new_tree.get_revision_id())
 
1573
        self.assertEqual(tree.branch.base, old_branch.base)
 
1574
        self.assertEqual(tree.branch.base, new_branch.base)
 
1575
        self.assertIs(None, specific_files)
 
1576
        self.assertEqual(tree.basedir, extra_trees[0].basedir)