← 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: Ian Clatworthy
  • Date: 2007-08-13 14:33:10 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070813143310-twhj4la0qnupvze8
Added Quick Start Summary

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import os
18
18
from cStringIO import StringIO
 
19
import errno
19
20
import subprocess
20
 
import sys
21
 
import tempfile
22
 
 
23
 
from bzrlib import (
24
 
    diff,
25
 
    errors,
26
 
    osutils,
27
 
    patiencediff,
28
 
    _patiencediff_py,
29
 
    revision as _mod_revision,
30
 
    revisionspec,
31
 
    revisiontree,
32
 
    tests,
33
 
    transform,
34
 
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features
37
 
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
 
39
 
 
40
 
class _AttribFeature(tests.Feature):
 
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?"""
41
33
 
42
34
    def _probe(self):
43
 
        if (sys.platform not in ('cygwin', 'win32')):
44
 
            return False
45
35
        try:
46
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
47
 
        except OSError, e:
 
36
            os.stat(u'\u03b1')
 
37
        except UnicodeEncodeError:
48
38
            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')
59
 
 
 
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
        
60
59
 
61
60
def udiff_lines(old, new, allow_binary=False):
62
61
    output = StringIO()
63
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
62
    internal_diff('old', old, 'new', new, output, allow_binary)
64
63
    output.seek(0, 0)
65
64
    return output.readlines()
66
65
 
70
69
        # StringIO has no fileno, so it tests a different codepath
71
70
        output = StringIO()
72
71
    else:
73
 
        output = tempfile.TemporaryFile()
 
72
        output = TemporaryFile()
74
73
    try:
75
 
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
76
 
    except errors.NoDiff:
77
 
        raise tests.TestSkipped('external "diff" not present to test')
 
74
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
75
    except NoDiff:
 
76
        raise TestSkipped('external "diff" not present to test')
78
77
    output.seek(0, 0)
79
78
    lines = output.readlines()
80
79
    output.close()
81
80
    return lines
82
81
 
83
82
 
84
 
class TestDiff(tests.TestCase):
 
83
class TestDiff(TestCase):
85
84
 
86
85
    def test_add_nl(self):
87
86
        """diff generates a valid diff for patches that add a newline"""
123
122
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
124
123
 
125
124
    def test_binary_lines(self):
126
 
        empty = []
127
 
        uni_lines = [1023 * 'a' + '\x00']
128
 
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
129
 
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
130
 
        udiff_lines(uni_lines , empty, allow_binary=True)
131
 
        udiff_lines(empty, uni_lines, allow_binary=True)
 
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)
132
129
 
133
130
    def test_external_diff(self):
134
131
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
164
161
        orig_path = os.environ['PATH']
165
162
        try:
166
163
            os.environ['PATH'] = ''
167
 
            self.assertRaises(errors.NoDiff, diff.external_diff,
 
164
            self.assertRaises(NoDiff, external_diff,
168
165
                              'old', ['boo\n'], 'new', ['goo\n'],
169
166
                              StringIO(), diff_opts=['-u'])
170
167
        finally:
171
168
            os.environ['PATH'] = orig_path
172
 
 
 
169
        
173
170
    def test_internal_diff_default(self):
174
171
        # Default internal diff encoding is utf8
175
172
        output = StringIO()
176
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
177
 
                           u'new_\xe5', ['new_text\n'], output)
 
173
        internal_diff(u'old_\xb5', ['old_text\n'],
 
174
                    u'new_\xe5', ['new_text\n'], output)
178
175
        lines = output.getvalue().splitlines(True)
179
176
        self.check_patch(lines)
180
177
        self.assertEquals(['--- old_\xc2\xb5\n',
188
185
 
189
186
    def test_internal_diff_utf8(self):
190
187
        output = StringIO()
191
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
192
 
                           u'new_\xe5', ['new_text\n'], output,
193
 
                           path_encoding='utf8')
 
188
        internal_diff(u'old_\xb5', ['old_text\n'],
 
189
                    u'new_\xe5', ['new_text\n'], output,
 
190
                    path_encoding='utf8')
194
191
        lines = output.getvalue().splitlines(True)
195
192
        self.check_patch(lines)
196
193
        self.assertEquals(['--- old_\xc2\xb5\n',
204
201
 
205
202
    def test_internal_diff_iso_8859_1(self):
206
203
        output = StringIO()
207
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
208
 
                           u'new_\xe5', ['new_text\n'], output,
209
 
                           path_encoding='iso-8859-1')
 
204
        internal_diff(u'old_\xb5', ['old_text\n'],
 
205
                    u'new_\xe5', ['new_text\n'], output,
 
206
                    path_encoding='iso-8859-1')
210
207
        lines = output.getvalue().splitlines(True)
211
208
        self.check_patch(lines)
212
209
        self.assertEquals(['--- old_\xb5\n',
218
215
                          ]
219
216
                          , lines)
220
217
 
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
 
 
233
218
    def test_internal_diff_returns_bytes(self):
234
219
        import StringIO
235
220
        output = StringIO.StringIO()
236
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
237
 
                            u'new_\xe5', ['new_text\n'], output)
 
221
        internal_diff(u'old_\xb5', ['old_text\n'],
 
222
                    u'new_\xe5', ['new_text\n'], output)
238
223
        self.failUnless(isinstance(output.getvalue(), str),
239
224
            'internal_diff should return bytestrings')
240
225
 
241
226
 
242
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
227
class TestDiffFiles(TestCaseInTempDir):
243
228
 
244
229
    def test_external_diff_binary(self):
245
230
        """The output when using external diff should use diff's i18n error"""
258
243
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
259
244
 
260
245
 
261
 
class TestShowDiffTreesHelper(tests.TestCaseWithTransport):
 
246
class TestShowDiffTreesHelper(TestCaseWithTransport):
262
247
    """Has a helper for running show_diff_trees"""
263
248
 
264
249
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
267
252
            extra_trees = (working_tree,)
268
253
        else:
269
254
            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/')
 
255
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
256
                        extra_trees=extra_trees, old_label='old/',
 
257
                        new_label='new/')
274
258
        return output.getvalue()
275
259
 
276
260
 
341
325
+file2 contents at rev 3
342
326
 
343
327
''')
344
 
 
 
328
        
345
329
    def test_diff_add_files(self):
346
 
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
 
330
        tree1 = self.b.repository.revision_tree(None)
347
331
        tree2 = self.b.repository.revision_tree('rev-1')
348
332
        output = self.get_diff(tree1, tree2)
349
333
        # the files have the epoch time stamp for the tree in which
383
367
        self.wt.rename_one('file1', 'file1b')
384
368
        old_tree = self.b.repository.revision_tree('rev-1')
385
369
        new_tree = self.b.repository.revision_tree('rev-4')
386
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
 
370
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
387
371
                            working_tree=self.wt)
388
372
        self.assertContainsRe(out, 'file1\t')
389
373
 
395
379
        self.wt.rename_one('file1', 'dir1/file1')
396
380
        old_tree = self.b.repository.revision_tree('rev-1')
397
381
        new_tree = self.b.repository.revision_tree('rev-4')
398
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
 
382
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
399
383
                            working_tree=self.wt)
400
384
        self.assertContainsRe(out, 'file1\t')
401
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
 
385
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
402
386
                            working_tree=self.wt)
403
387
        self.assertNotContainsRe(out, 'file1\t')
404
388
 
415
399
        tree.commit('one', rev_id='rev-1')
416
400
 
417
401
        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')
 
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')
424
408
 
425
409
    def test_modified_file_in_renamed_dir(self):
426
410
        """Test when a file is modified in a renamed directory."""
432
416
 
433
417
        tree.rename_one('dir', 'other')
434
418
        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")
 
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")
438
422
        # XXX: This is technically incorrect, because it used to be at another
439
423
        # 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')
 
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')
444
428
 
445
429
    def test_renamed_directory(self):
446
430
        """Test when only a directory is only renamed."""
451
435
        tree.commit('one', rev_id='rev-1')
452
436
 
453
437
        tree.rename_one('dir', 'newdir')
454
 
        d = self.get_diff(tree.basis_tree(), tree)
 
438
        diff = self.get_diff(tree.basis_tree(), tree)
455
439
        # Renaming a directory should be a single "you renamed this dir" even
456
440
        # when there are files inside.
457
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
441
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
458
442
 
459
443
    def test_renamed_file(self):
460
444
        """Test when a file is only renamed."""
464
448
        tree.commit('one', rev_id='rev-1')
465
449
 
466
450
        tree.rename_one('file', 'newname')
467
 
        d = self.get_diff(tree.basis_tree(), tree)
468
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
451
        diff = self.get_diff(tree.basis_tree(), tree)
 
452
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
469
453
        # We shouldn't have a --- or +++ line, because there is no content
470
454
        # change
471
 
        self.assertNotContainsRe(d, '---')
 
455
        self.assertNotContainsRe(diff, '---')
472
456
 
473
457
    def test_renamed_and_modified_file(self):
474
458
        """Test when a file is only renamed."""
479
463
 
480
464
        tree.rename_one('file', 'newname')
481
465
        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'")
 
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')
524
472
 
525
473
    def test_binary_unicode_filenames(self):
526
474
        """Test that contents of files are *not* encoded in UTF-8 when there
527
475
        is a binary file in the diff.
528
476
        """
529
477
        # See https://bugs.launchpad.net/bugs/110092.
530
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
478
        self.requireFeature(UnicodeFilename)
531
479
 
532
480
        # This bug isn't triggered with cStringIO.
533
481
        from StringIO import StringIO
541
489
        tree.add([alpha], ['file-id'])
542
490
        tree.add([omega], ['file-id-2'])
543
491
        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))
 
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):
811
503
 
812
504
    def test_unique_lcs(self):
813
 
        unique_lcs = self._unique_lcs
 
505
        unique_lcs = bzrlib.patiencediff.unique_lcs
814
506
        self.assertEquals(unique_lcs('', ''), [])
815
 
        self.assertEquals(unique_lcs('', 'a'), [])
816
 
        self.assertEquals(unique_lcs('a', ''), [])
817
507
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
818
508
        self.assertEquals(unique_lcs('a', 'b'), [])
819
509
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
820
510
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
821
511
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
822
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
512
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
823
513
                                                         (3,3), (4,4)])
824
514
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
825
515
 
826
516
    def test_recurse_matches(self):
827
517
        def test_one(a, b, matches):
828
518
            test_matches = []
829
 
            self._recurse_matches(
830
 
                a, b, 0, 0, len(a), len(b), test_matches, 10)
 
519
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
 
520
                test_matches, 10)
831
521
            self.assertEquals(test_matches, matches)
832
522
 
833
523
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
834
524
                 [(0, 0), (2, 2), (4, 4)])
835
525
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
836
526
                 [(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)])
842
527
 
843
 
        # recurse_matches doesn't match non-unique
 
528
        # recurse_matches doesn't match non-unique 
844
529
        # lines surrounded by bogus text.
845
530
        # The update has been done in patiencediff.SequenceMatcher instead
846
531
 
850
535
        # This is what it currently gives:
851
536
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
852
537
 
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
 
 
867
538
    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
 
868
547
        # Some basic matching tests
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
 
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 
881
558
        # a copied block stays attached to the previous section,
882
559
        # not the later one.
883
560
        # difflib would tend to grab the trailing longest match
884
561
        # which would make the diff not look right
885
 
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
886
 
                              [(0, 0, 6), (6, 11, 10)])
 
562
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
563
                   [(0, 0, 6), (6, 11, 10)])
887
564
 
888
565
        # make sure it supports passing in lists
889
 
        self.assertDiffBlocks(
 
566
        chk_blocks(
890
567
                   ['hello there\n',
891
568
                    'world\n',
892
569
                    'how are you today?\n'],
896
573
 
897
574
        # non unique lines surrounded by non-matching lines
898
575
        # won't be found
899
 
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
576
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
900
577
 
901
578
        # But they only need to be locally unique
902
 
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
579
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
903
580
 
904
581
        # non unique blocks won't be matched
905
 
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
582
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
906
583
 
907
584
        # but locally unique ones will
908
 
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
585
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
909
586
                                              (5,4,1), (7,5,2), (10,8,1)])
910
587
 
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)])
 
588
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
589
        chk_blocks('abbabbbb', 'cabbabbc', [])
 
590
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
938
591
 
939
592
    def test_opcodes(self):
940
593
        def chk_ops(a, b, expected_codes):
941
 
            s = self._PatienceSequenceMatcher(None, a, b)
 
594
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
942
595
            self.assertEquals(expected_codes, s.get_opcodes())
943
596
 
944
597
        chk_ops('', '', [])
945
598
        chk_ops([], [], [])
946
 
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
947
 
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
948
599
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
949
600
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
950
601
                                 ('replace', 3,4, 3,4)
983
634
                 ('delete', 1,2, 1,1),
984
635
                 ('equal',  2,3, 1,2),
985
636
                ])
986
 
        chk_ops('aBccDe', 'abccde',
 
637
        chk_ops('aBccDe', 'abccde', 
987
638
                [('equal',   0,1, 0,1),
988
639
                 ('replace', 1,5, 1,5),
989
640
                 ('equal',   5,6, 5,6),
990
641
                ])
991
 
        chk_ops('aBcDec', 'abcdec',
 
642
        chk_ops('aBcDec', 'abcdec', 
992
643
                [('equal',   0,1, 0,1),
993
644
                 ('replace', 1,2, 1,2),
994
645
                 ('equal',   2,3, 2,3),
995
646
                 ('replace', 3,4, 3,4),
996
647
                 ('equal',   4,6, 4,6),
997
648
                ])
998
 
        chk_ops('aBcdEcdFg', 'abcdecdfg',
 
649
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
999
650
                [('equal',   0,1, 0,1),
1000
651
                 ('replace', 1,8, 1,8),
1001
652
                 ('equal',   8,9, 8,9)
1002
653
                ])
1003
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
 
654
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
1004
655
                [('equal',   0,1, 0,1),
1005
656
                 ('replace', 1,2, 1,2),
1006
657
                 ('equal',   2,4, 2,4),
1012
663
                 ('equal',   10,11, 8,9)
1013
664
                ])
1014
665
 
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
 
 
1052
666
    def test_multiple_ranges(self):
1053
667
        # There was an earlier bug where we used a bad set of ranges,
1054
668
        # this triggers that specific bug, to make sure it doesn't regress
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)])
 
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)])
1062
685
 
1063
686
        # These are rot13 code snippets.
1064
 
        self.assertDiffBlocks('''\
 
687
        chk_blocks('''\
1065
688
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1066
689
    """
1067
690
    gnxrf_netf = ['svyr*']
1068
691
    gnxrf_bcgvbaf = ['ab-erphefr']
1069
 
 
 
692
  
1070
693
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1071
694
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1072
695
        vs vf_dhvrg():
1080
703
'''.splitlines(True), '''\
1081
704
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1082
705
 
1083
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
 
706
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
1084
707
    nqq gurz.
1085
708
    """
1086
709
    gnxrf_netf = ['svyr*']
1113
736
                 'how are you today?\n']
1114
737
        txt_b = ['hello there\n',
1115
738
                 'how are you today?\n']
1116
 
        unified_diff = patiencediff.unified_diff
1117
 
        psm = self._PatienceSequenceMatcher
1118
 
        self.assertEquals(['--- \n',
1119
 
                           '+++ \n',
 
739
        unified_diff = bzrlib.patiencediff.unified_diff
 
740
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
741
        self.assertEquals([ '---  \n',
 
742
                           '+++  \n',
1120
743
                           '@@ -1,3 +1,2 @@\n',
1121
744
                           ' hello there\n',
1122
745
                           '-world\n',
1127
750
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1128
751
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1129
752
        # This is the result with LongestCommonSubstring matching
1130
 
        self.assertEquals(['--- \n',
1131
 
                           '+++ \n',
 
753
        self.assertEquals(['---  \n',
 
754
                           '+++  \n',
1132
755
                           '@@ -1,6 +1,11 @@\n',
1133
756
                           ' a\n',
1134
757
                           ' b\n',
1143
766
                           ' f\n']
1144
767
                          , list(unified_diff(txt_a, txt_b)))
1145
768
        # And the patience diff
1146
 
        self.assertEquals(['--- \n',
1147
 
                           '+++ \n',
 
769
        self.assertEquals(['---  \n',
 
770
                           '+++  \n',
1148
771
                           '@@ -4,6 +4,11 @@\n',
1149
772
                           ' d\n',
1150
773
                           ' e\n',
1161
784
                          , list(unified_diff(txt_a, txt_b,
1162
785
                                 sequencematcher=psm)))
1163
786
 
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
 
787
 
 
788
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1218
789
 
1219
790
    def test_patience_unified_diff_files(self):
1220
791
        txt_a = ['hello there\n',
1225
796
        open('a1', 'wb').writelines(txt_a)
1226
797
        open('b1', 'wb').writelines(txt_b)
1227
798
 
1228
 
        unified_diff_files = patiencediff.unified_diff_files
1229
 
        psm = self._PatienceSequenceMatcher
1230
 
        self.assertEquals(['--- a1\n',
1231
 
                           '+++ b1\n',
 
799
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
 
800
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
801
        self.assertEquals(['--- a1 \n',
 
802
                           '+++ b1 \n',
1232
803
                           '@@ -1,3 +1,2 @@\n',
1233
804
                           ' hello there\n',
1234
805
                           '-world\n',
1243
814
        open('b2', 'wb').writelines(txt_b)
1244
815
 
1245
816
        # This is the result with LongestCommonSubstring matching
1246
 
        self.assertEquals(['--- a2\n',
1247
 
                           '+++ b2\n',
 
817
        self.assertEquals(['--- a2 \n',
 
818
                           '+++ b2 \n',
1248
819
                           '@@ -1,6 +1,11 @@\n',
1249
820
                           ' a\n',
1250
821
                           ' b\n',
1260
831
                          , list(unified_diff_files('a2', 'b2')))
1261
832
 
1262
833
        # And the patience diff
1263
 
        self.assertEquals(['--- a2\n',
1264
 
                           '+++ b2\n',
 
834
        self.assertEquals(['--- a2 \n',
 
835
                           '+++ b2 \n',
1265
836
                           '@@ -4,6 +4,11 @@\n',
1266
837
                           ' d\n',
1267
838
                           ' e\n',
1277
848
                          ]
1278
849
                          , list(unified_diff_files('a2', 'b2',
1279
850
                                 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