← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

(parthm) Better regex compile errors (Parth Malwankar)

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.osutils as osutils
26
 
import bzrlib.patiencediff
27
 
from bzrlib.tests import (TestCase, TestCaseWithTransport,
28
 
                          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')
29
59
 
30
60
 
31
61
def udiff_lines(old, new, allow_binary=False):
32
62
    output = StringIO()
33
 
    internal_diff('old', old, 'new', new, output, allow_binary)
 
63
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
34
64
    output.seek(0, 0)
35
65
    return output.readlines()
36
66
 
40
70
        # StringIO has no fileno, so it tests a different codepath
41
71
        output = StringIO()
42
72
    else:
43
 
        output = TemporaryFile()
 
73
        output = tempfile.TemporaryFile()
44
74
    try:
45
 
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
46
 
    except NoDiff:
47
 
        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')
48
78
    output.seek(0, 0)
49
79
    lines = output.readlines()
50
80
    output.close()
51
81
    return lines
52
82
 
53
83
 
54
 
class TestDiff(TestCase):
 
84
class TestDiff(tests.TestCase):
55
85
 
56
86
    def test_add_nl(self):
57
87
        """diff generates a valid diff for patches that add a newline"""
93
123
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
94
124
 
95
125
    def test_binary_lines(self):
96
 
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
97
 
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
98
 
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
99
 
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
 
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)
100
132
 
101
133
    def test_external_diff(self):
102
134
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
132
164
        orig_path = os.environ['PATH']
133
165
        try:
134
166
            os.environ['PATH'] = ''
135
 
            self.assertRaises(NoDiff, external_diff,
 
167
            self.assertRaises(errors.NoDiff, diff.external_diff,
136
168
                              'old', ['boo\n'], 'new', ['goo\n'],
137
169
                              StringIO(), diff_opts=['-u'])
138
170
        finally:
139
171
            os.environ['PATH'] = orig_path
140
 
        
 
172
 
141
173
    def test_internal_diff_default(self):
142
174
        # Default internal diff encoding is utf8
143
175
        output = StringIO()
144
 
        internal_diff(u'old_\xb5', ['old_text\n'],
145
 
                    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)
146
178
        lines = output.getvalue().splitlines(True)
147
179
        self.check_patch(lines)
148
180
        self.assertEquals(['--- old_\xc2\xb5\n',
156
188
 
157
189
    def test_internal_diff_utf8(self):
158
190
        output = StringIO()
159
 
        internal_diff(u'old_\xb5', ['old_text\n'],
160
 
                    u'new_\xe5', ['new_text\n'], output,
161
 
                    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')
162
194
        lines = output.getvalue().splitlines(True)
163
195
        self.check_patch(lines)
164
196
        self.assertEquals(['--- old_\xc2\xb5\n',
172
204
 
173
205
    def test_internal_diff_iso_8859_1(self):
174
206
        output = StringIO()
175
 
        internal_diff(u'old_\xb5', ['old_text\n'],
176
 
                    u'new_\xe5', ['new_text\n'], output,
177
 
                    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')
178
210
        lines = output.getvalue().splitlines(True)
179
211
        self.check_patch(lines)
180
212
        self.assertEquals(['--- old_\xb5\n',
186
218
                          ]
187
219
                          , lines)
188
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
 
189
233
    def test_internal_diff_returns_bytes(self):
190
234
        import StringIO
191
235
        output = StringIO.StringIO()
192
 
        internal_diff(u'old_\xb5', ['old_text\n'],
193
 
                    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)
194
238
        self.failUnless(isinstance(output.getvalue(), str),
195
239
            'internal_diff should return bytestrings')
196
240
 
197
241
 
198
 
class TestDiffFiles(TestCaseInTempDir):
 
242
class TestDiffFiles(tests.TestCaseInTempDir):
199
243
 
200
244
    def test_external_diff_binary(self):
201
245
        """The output when using external diff should use diff's i18n error"""
214
258
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
215
259
 
216
260
 
217
 
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
261
class TestShowDiffTreesHelper(tests.TestCaseWithTransport):
218
262
    """Has a helper for running show_diff_trees"""
219
263
 
220
264
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
223
267
            extra_trees = (working_tree,)
224
268
        else:
225
269
            extra_trees = ()
226
 
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
227
 
                        extra_trees=extra_trees, old_label='old/',
228
 
                        new_label='new/')
 
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/')
229
274
        return output.getvalue()
230
275
 
231
276
 
296
341
+file2 contents at rev 3
297
342
 
298
343
''')
299
 
        
 
344
 
300
345
    def test_diff_add_files(self):
301
 
        tree1 = self.b.repository.revision_tree(None)
 
346
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
302
347
        tree2 = self.b.repository.revision_tree('rev-1')
303
348
        output = self.get_diff(tree1, tree2)
304
349
        # the files have the epoch time stamp for the tree in which
338
383
        self.wt.rename_one('file1', 'file1b')
339
384
        old_tree = self.b.repository.revision_tree('rev-1')
340
385
        new_tree = self.b.repository.revision_tree('rev-4')
341
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
386
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
342
387
                            working_tree=self.wt)
343
388
        self.assertContainsRe(out, 'file1\t')
344
389
 
350
395
        self.wt.rename_one('file1', 'dir1/file1')
351
396
        old_tree = self.b.repository.revision_tree('rev-1')
352
397
        new_tree = self.b.repository.revision_tree('rev-4')
353
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
398
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
354
399
                            working_tree=self.wt)
355
400
        self.assertContainsRe(out, 'file1\t')
356
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
401
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
357
402
                            working_tree=self.wt)
358
403
        self.assertNotContainsRe(out, 'file1\t')
359
404
 
370
415
        tree.commit('one', rev_id='rev-1')
371
416
 
372
417
        self.build_tree_contents([('tree/file', 'new contents\n')])
373
 
        diff = self.get_diff(tree.basis_tree(), tree)
374
 
        self.assertContainsRe(diff, "=== modified file 'file'\n")
375
 
        self.assertContainsRe(diff, '--- old/file\t')
376
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
377
 
        self.assertContainsRe(diff, '-contents\n'
378
 
                                    '\\+new contents\n')
 
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')
379
424
 
380
425
    def test_modified_file_in_renamed_dir(self):
381
426
        """Test when a file is modified in a renamed directory."""
387
432
 
388
433
        tree.rename_one('dir', 'other')
389
434
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
390
 
        diff = self.get_diff(tree.basis_tree(), tree)
391
 
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
392
 
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
 
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")
393
438
        # XXX: This is technically incorrect, because it used to be at another
394
439
        # location. What to do?
395
 
        self.assertContainsRe(diff, '--- old/dir/file\t')
396
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
397
 
        self.assertContainsRe(diff, '-contents\n'
398
 
                                    '\\+new contents\n')
 
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')
399
444
 
400
445
    def test_renamed_directory(self):
401
446
        """Test when only a directory is only renamed."""
406
451
        tree.commit('one', rev_id='rev-1')
407
452
 
408
453
        tree.rename_one('dir', 'newdir')
409
 
        diff = self.get_diff(tree.basis_tree(), tree)
 
454
        d = self.get_diff(tree.basis_tree(), tree)
410
455
        # Renaming a directory should be a single "you renamed this dir" even
411
456
        # when there are files inside.
412
 
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
 
457
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
413
458
 
414
459
    def test_renamed_file(self):
415
460
        """Test when a file is only renamed."""
419
464
        tree.commit('one', rev_id='rev-1')
420
465
 
421
466
        tree.rename_one('file', 'newname')
422
 
        diff = self.get_diff(tree.basis_tree(), tree)
423
 
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
467
        d = self.get_diff(tree.basis_tree(), tree)
 
468
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
424
469
        # We shouldn't have a --- or +++ line, because there is no content
425
470
        # change
426
 
        self.assertNotContainsRe(diff, '---')
 
471
        self.assertNotContainsRe(d, '---')
427
472
 
428
473
    def test_renamed_and_modified_file(self):
429
474
        """Test when a file is only renamed."""
434
479
 
435
480
        tree.rename_one('file', 'newname')
436
481
        self.build_tree_contents([('tree/newname', 'new contents\n')])
437
 
        diff = self.get_diff(tree.basis_tree(), tree)
438
 
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
439
 
        self.assertContainsRe(diff, '--- old/file\t')
440
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
441
 
        self.assertContainsRe(diff, '-contents\n'
442
 
                                    '\\+new contents\n')
443
 
 
444
 
 
445
 
class TestPatienceDiffLib(TestCase):
 
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))
446
811
 
447
812
    def test_unique_lcs(self):
448
 
        unique_lcs = bzrlib.patiencediff.unique_lcs
 
813
        unique_lcs = self._unique_lcs
449
814
        self.assertEquals(unique_lcs('', ''), [])
 
815
        self.assertEquals(unique_lcs('', 'a'), [])
 
816
        self.assertEquals(unique_lcs('a', ''), [])
450
817
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
451
818
        self.assertEquals(unique_lcs('a', 'b'), [])
452
819
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
453
820
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
454
821
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
455
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
 
822
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
456
823
                                                         (3,3), (4,4)])
457
824
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
458
825
 
459
826
    def test_recurse_matches(self):
460
827
        def test_one(a, b, matches):
461
828
            test_matches = []
462
 
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
463
 
                test_matches, 10)
 
829
            self._recurse_matches(
 
830
                a, b, 0, 0, len(a), len(b), test_matches, 10)
464
831
            self.assertEquals(test_matches, matches)
465
832
 
466
833
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
467
834
                 [(0, 0), (2, 2), (4, 4)])
468
835
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
469
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)])
470
842
 
471
 
        # recurse_matches doesn't match non-unique 
 
843
        # recurse_matches doesn't match non-unique
472
844
        # lines surrounded by bogus text.
473
845
        # The update has been done in patiencediff.SequenceMatcher instead
474
846
 
478
850
        # This is what it currently gives:
479
851
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
480
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
 
481
867
    def test_matching_blocks(self):
482
 
        def chk_blocks(a, b, expected_blocks):
483
 
            # difflib always adds a signature of the total
484
 
            # length, with no matching entries at the end
485
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
486
 
            blocks = s.get_matching_blocks()
487
 
            self.assertEquals((len(a), len(b), 0), blocks[-1])
488
 
            self.assertEquals(expected_blocks, blocks[:-1])
489
 
 
490
868
        # Some basic matching tests
491
 
        chk_blocks('', '', [])
492
 
        chk_blocks([], [], [])
493
 
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
494
 
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
495
 
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
496
 
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
497
 
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
498
 
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
499
 
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
500
 
        # This may check too much, but it checks to see that 
 
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
501
881
        # a copied block stays attached to the previous section,
502
882
        # not the later one.
503
883
        # difflib would tend to grab the trailing longest match
504
884
        # which would make the diff not look right
505
 
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
506
 
                   [(0, 0, 6), (6, 11, 10)])
 
885
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
886
                              [(0, 0, 6), (6, 11, 10)])
507
887
 
508
888
        # make sure it supports passing in lists
509
 
        chk_blocks(
 
889
        self.assertDiffBlocks(
510
890
                   ['hello there\n',
511
891
                    'world\n',
512
892
                    'how are you today?\n'],
516
896
 
517
897
        # non unique lines surrounded by non-matching lines
518
898
        # won't be found
519
 
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
899
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
520
900
 
521
901
        # But they only need to be locally unique
522
 
        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)])
523
903
 
524
904
        # non unique blocks won't be matched
525
 
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
905
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
526
906
 
527
907
        # but locally unique ones will
528
 
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
908
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
529
909
                                              (5,4,1), (7,5,2), (10,8,1)])
530
910
 
531
 
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
532
 
        chk_blocks('abbabbbb', 'cabbabbc', [])
533
 
        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)])
534
938
 
535
939
    def test_opcodes(self):
536
940
        def chk_ops(a, b, expected_codes):
537
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
941
            s = self._PatienceSequenceMatcher(None, a, b)
538
942
            self.assertEquals(expected_codes, s.get_opcodes())
539
943
 
540
944
        chk_ops('', '', [])
541
945
        chk_ops([], [], [])
 
946
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
 
947
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
542
948
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
543
949
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
544
950
                                 ('replace', 3,4, 3,4)
577
983
                 ('delete', 1,2, 1,1),
578
984
                 ('equal',  2,3, 1,2),
579
985
                ])
580
 
        chk_ops('aBccDe', 'abccde', 
 
986
        chk_ops('aBccDe', 'abccde',
581
987
                [('equal',   0,1, 0,1),
582
988
                 ('replace', 1,5, 1,5),
583
989
                 ('equal',   5,6, 5,6),
584
990
                ])
585
 
        chk_ops('aBcDec', 'abcdec', 
 
991
        chk_ops('aBcDec', 'abcdec',
586
992
                [('equal',   0,1, 0,1),
587
993
                 ('replace', 1,2, 1,2),
588
994
                 ('equal',   2,3, 2,3),
589
995
                 ('replace', 3,4, 3,4),
590
996
                 ('equal',   4,6, 4,6),
591
997
                ])
592
 
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
 
998
        chk_ops('aBcdEcdFg', 'abcdecdfg',
593
999
                [('equal',   0,1, 0,1),
594
1000
                 ('replace', 1,8, 1,8),
595
1001
                 ('equal',   8,9, 8,9)
596
1002
                ])
597
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
1003
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
598
1004
                [('equal',   0,1, 0,1),
599
1005
                 ('replace', 1,2, 1,2),
600
1006
                 ('equal',   2,4, 2,4),
606
1012
                 ('equal',   10,11, 8,9)
607
1013
                ])
608
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
 
609
1052
    def test_multiple_ranges(self):
610
1053
        # There was an earlier bug where we used a bad set of ranges,
611
1054
        # this triggers that specific bug, to make sure it doesn't regress
612
 
        def chk_blocks(a, b, expected_blocks):
613
 
            # difflib always adds a signature of the total
614
 
            # length, with no matching entries at the end
615
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
616
 
            blocks = s.get_matching_blocks()
617
 
            x = blocks.pop()
618
 
            self.assertEquals(x, (len(a), len(b), 0))
619
 
            self.assertEquals(expected_blocks, blocks)
620
 
 
621
 
        chk_blocks('abcdefghijklmnop'
622
 
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
623
 
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
624
 
 
625
 
        chk_blocks('ABCd efghIjk  L'
626
 
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
627
 
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
 
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)])
628
1062
 
629
1063
        # These are rot13 code snippets.
630
 
        chk_blocks('''\
 
1064
        self.assertDiffBlocks('''\
631
1065
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
632
1066
    """
633
1067
    gnxrf_netf = ['svyr*']
634
1068
    gnxrf_bcgvbaf = ['ab-erphefr']
635
 
  
 
1069
 
636
1070
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
637
1071
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
638
1072
        vs vf_dhvrg():
646
1080
'''.splitlines(True), '''\
647
1081
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
648
1082
 
649
 
    --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
650
1084
    nqq gurz.
651
1085
    """
652
1086
    gnxrf_netf = ['svyr*']
679
1113
                 'how are you today?\n']
680
1114
        txt_b = ['hello there\n',
681
1115
                 'how are you today?\n']
682
 
        unified_diff = bzrlib.patiencediff.unified_diff
683
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
684
 
        self.assertEquals([ '---  \n',
685
 
                           '+++  \n',
 
1116
        unified_diff = patiencediff.unified_diff
 
1117
        psm = self._PatienceSequenceMatcher
 
1118
        self.assertEquals(['--- \n',
 
1119
                           '+++ \n',
686
1120
                           '@@ -1,3 +1,2 @@\n',
687
1121
                           ' hello there\n',
688
1122
                           '-world\n',
693
1127
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
694
1128
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
695
1129
        # This is the result with LongestCommonSubstring matching
696
 
        self.assertEquals(['---  \n',
697
 
                           '+++  \n',
 
1130
        self.assertEquals(['--- \n',
 
1131
                           '+++ \n',
698
1132
                           '@@ -1,6 +1,11 @@\n',
699
1133
                           ' a\n',
700
1134
                           ' b\n',
709
1143
                           ' f\n']
710
1144
                          , list(unified_diff(txt_a, txt_b)))
711
1145
        # And the patience diff
712
 
        self.assertEquals(['---  \n',
713
 
                           '+++  \n',
 
1146
        self.assertEquals(['--- \n',
 
1147
                           '+++ \n',
714
1148
                           '@@ -4,6 +4,11 @@\n',
715
1149
                           ' d\n',
716
1150
                           ' e\n',
727
1161
                          , list(unified_diff(txt_a, txt_b,
728
1162
                                 sequencematcher=psm)))
729
1163
 
730
 
 
731
 
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
732
1218
 
733
1219
    def test_patience_unified_diff_files(self):
734
1220
        txt_a = ['hello there\n',
739
1225
        open('a1', 'wb').writelines(txt_a)
740
1226
        open('b1', 'wb').writelines(txt_b)
741
1227
 
742
 
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
743
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
744
 
        self.assertEquals(['--- a1 \n',
745
 
                           '+++ b1 \n',
 
1228
        unified_diff_files = patiencediff.unified_diff_files
 
1229
        psm = self._PatienceSequenceMatcher
 
1230
        self.assertEquals(['--- a1\n',
 
1231
                           '+++ b1\n',
746
1232
                           '@@ -1,3 +1,2 @@\n',
747
1233
                           ' hello there\n',
748
1234
                           '-world\n',
757
1243
        open('b2', 'wb').writelines(txt_b)
758
1244
 
759
1245
        # This is the result with LongestCommonSubstring matching
760
 
        self.assertEquals(['--- a2 \n',
761
 
                           '+++ b2 \n',
 
1246
        self.assertEquals(['--- a2\n',
 
1247
                           '+++ b2\n',
762
1248
                           '@@ -1,6 +1,11 @@\n',
763
1249
                           ' a\n',
764
1250
                           ' b\n',
774
1260
                          , list(unified_diff_files('a2', 'b2')))
775
1261
 
776
1262
        # And the patience diff
777
 
        self.assertEquals(['--- a2 \n',
778
 
                           '+++ b2 \n',
 
1263
        self.assertEquals(['--- a2\n',
 
1264
                           '+++ b2\n',
779
1265
                           '@@ -4,6 +4,11 @@\n',
780
1266
                           ' d\n',
781
1267
                           ' e\n',
791
1277
                          ]
792
1278
                          , list(unified_diff_files('a2', 'b2',
793
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