← 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: Patch Queue Manager
  • Date: 2015-12-17 18:39:00 UTC
  • mfrom: (6606.1.2 fix-float)
  • Revision ID: pqm@pqm.ubuntu.com-20151217183900-0719du2uv1kwu3lc
(vila) Inline testtools private method to fix an issue in xenial (the
 private implementation has changed in an backward incompatible way).
 (Jelmer Vernooij)

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