← 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: Andrew Bennetts
  • Date: 2010-10-08 08:15:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101008081514-dviqzrdfwyzsqbz2
Split NEWS into per-release doc/en/release-notes/bzr-*.txt

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