← 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: Arnaud Jeansen
  • Date: 2010-03-19 23:58:06 UTC
  • mto: This revision was merged to the branch mainline in revision 5126.
  • Revision ID: arnaud.jeansen@gmail.com-20100319235806-n0owdq874qsrb12u
Go back to unified report_delta method (i.e. former TreeDelta.show())

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Development 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
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
import os.path
18
19
from cStringIO import StringIO
19
20
import errno
 
21
import subprocess
 
22
import sys
20
23
from tempfile import TemporaryFile
21
24
 
22
 
from bzrlib.diff import internal_diff, external_diff, show_diff_trees
23
 
from bzrlib.errors import BinaryFile, NoDiff
 
25
from bzrlib import tests
 
26
from bzrlib.diff import (
 
27
    DiffFromTool,
 
28
    DiffPath,
 
29
    DiffSymlink,
 
30
    DiffTree,
 
31
    DiffText,
 
32
    external_diff,
 
33
    internal_diff,
 
34
    show_diff_trees,
 
35
    get_trees_and_branches_to_diff,
 
36
    )
 
37
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
 
38
import bzrlib.osutils as osutils
 
39
import bzrlib.revision as _mod_revision
 
40
import bzrlib.transform as transform
24
41
import bzrlib.patiencediff
25
 
from bzrlib.tests import (TestCase, TestCaseWithTransport,
 
42
import bzrlib._patiencediff_py
 
43
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
26
44
                          TestCaseInTempDir, TestSkipped)
 
45
from bzrlib.revisiontree import RevisionTree
 
46
from bzrlib.revisionspec import RevisionSpec
 
47
 
 
48
from bzrlib.tests.test_win32utils import BackslashDirSeparatorFeature
 
49
 
 
50
 
 
51
class _AttribFeature(Feature):
 
52
 
 
53
    def _probe(self):
 
54
        if (sys.platform not in ('cygwin', 'win32')):
 
55
            return False
 
56
        try:
 
57
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
 
58
        except OSError, e:
 
59
            return False
 
60
        return (0 == proc.wait())
 
61
 
 
62
    def feature_name(self):
 
63
        return 'attrib Windows command-line tool'
 
64
 
 
65
AttribFeature = _AttribFeature()
 
66
 
 
67
 
 
68
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
 
69
                                    'bzrlib._patiencediff_c')
27
70
 
28
71
 
29
72
def udiff_lines(old, new, allow_binary=False):
99
142
    def test_external_diff(self):
100
143
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
101
144
        self.check_patch(lines)
 
145
        self.assertEqual('\n', lines[-1])
102
146
 
103
147
    def test_external_diff_no_fileno(self):
104
148
        # Make sure that we can handle not having a fileno, even
107
151
                                     ['goo\n']*10000,
108
152
                                     use_stringio=True)
109
153
        self.check_patch(lines)
110
 
        
 
154
 
 
155
    def test_external_diff_binary_lang_c(self):
 
156
        old_env = {}
 
157
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
 
158
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
159
        try:
 
160
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
161
            # Older versions of diffutils say "Binary files", newer
 
162
            # versions just say "Files".
 
163
            self.assertContainsRe(lines[0],
 
164
                                  '(Binary f|F)iles old and new differ\n')
 
165
            self.assertEquals(lines[1:], ['\n'])
 
166
        finally:
 
167
            for lang, old_val in old_env.iteritems():
 
168
                osutils.set_or_unset_env(lang, old_val)
 
169
 
 
170
    def test_no_external_diff(self):
 
171
        """Check that NoDiff is raised when diff is not available"""
 
172
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
173
        orig_path = os.environ['PATH']
 
174
        try:
 
175
            os.environ['PATH'] = ''
 
176
            self.assertRaises(NoDiff, external_diff,
 
177
                              'old', ['boo\n'], 'new', ['goo\n'],
 
178
                              StringIO(), diff_opts=['-u'])
 
179
        finally:
 
180
            os.environ['PATH'] = orig_path
 
181
 
111
182
    def test_internal_diff_default(self):
112
183
        # Default internal diff encoding is utf8
113
184
        output = StringIO()
156
227
                          ]
157
228
                          , lines)
158
229
 
 
230
    def test_internal_diff_no_content(self):
 
231
        output = StringIO()
 
232
        internal_diff(u'old', [], u'new', [], output)
 
233
        self.assertEqual('', output.getvalue())
 
234
 
 
235
    def test_internal_diff_no_changes(self):
 
236
        output = StringIO()
 
237
        internal_diff(u'old', ['text\n', 'contents\n'],
 
238
                      u'new', ['text\n', 'contents\n'],
 
239
                      output)
 
240
        self.assertEqual('', output.getvalue())
 
241
 
159
242
    def test_internal_diff_returns_bytes(self):
160
243
        import StringIO
161
244
        output = StringIO.StringIO()
165
248
            'internal_diff should return bytestrings')
166
249
 
167
250
 
168
 
class TestDiffDates(TestCaseWithTransport):
 
251
class TestDiffFiles(TestCaseInTempDir):
 
252
 
 
253
    def test_external_diff_binary(self):
 
254
        """The output when using external diff should use diff's i18n error"""
 
255
        # Make sure external_diff doesn't fail in the current LANG
 
256
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
257
 
 
258
        cmd = ['diff', '-u', '--binary', 'old', 'new']
 
259
        open('old', 'wb').write('\x00foobar\n')
 
260
        open('new', 'wb').write('foo\x00bar\n')
 
261
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
 
262
                                     stdin=subprocess.PIPE)
 
263
        out, err = pipe.communicate()
 
264
        # Diff returns '2' on Binary files.
 
265
        self.assertEqual(2, pipe.returncode)
 
266
        # We should output whatever diff tells us, plus a trailing newline
 
267
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
 
268
 
 
269
 
 
270
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
271
    """Has a helper for running show_diff_trees"""
 
272
 
 
273
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
274
        output = StringIO()
 
275
        if working_tree is not None:
 
276
            extra_trees = (working_tree,)
 
277
        else:
 
278
            extra_trees = ()
 
279
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
280
                        extra_trees=extra_trees, old_label='old/',
 
281
                        new_label='new/')
 
282
        return output.getvalue()
 
283
 
 
284
 
 
285
class TestDiffDates(TestShowDiffTreesHelper):
169
286
 
170
287
    def setUp(self):
171
288
        super(TestDiffDates, self).setUp()
205
322
        # set the date stamps for files in the working tree to known values
206
323
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
207
324
 
208
 
    def get_diff(self, tree1, tree2):
209
 
        output = StringIO()
210
 
        show_diff_trees(tree1, tree2, output,
211
 
                        old_label='old/', new_label='new/')
212
 
        return output.getvalue()
213
 
 
214
325
    def test_diff_rev_tree_working_tree(self):
215
326
        output = self.get_diff(self.wt.basis_tree(), self.wt)
216
327
        # note that the date for old/file1 is from rev 2 rather than from
238
349
+file2 contents at rev 3
239
350
 
240
351
''')
241
 
        
 
352
 
242
353
    def test_diff_add_files(self):
243
 
        tree1 = self.b.repository.revision_tree(None)
 
354
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
244
355
        tree2 = self.b.repository.revision_tree('rev-1')
245
356
        output = self.get_diff(tree1, tree2)
246
357
        # the files have the epoch time stamp for the tree in which
275
386
 
276
387
''')
277
388
 
 
389
    def test_show_diff_specified(self):
 
390
        """A working tree filename can be used to identify a file"""
 
391
        self.wt.rename_one('file1', 'file1b')
 
392
        old_tree = self.b.repository.revision_tree('rev-1')
 
393
        new_tree = self.b.repository.revision_tree('rev-4')
 
394
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
 
395
                            working_tree=self.wt)
 
396
        self.assertContainsRe(out, 'file1\t')
 
397
 
 
398
    def test_recursive_diff(self):
 
399
        """Children of directories are matched"""
 
400
        os.mkdir('dir1')
 
401
        os.mkdir('dir2')
 
402
        self.wt.add(['dir1', 'dir2'])
 
403
        self.wt.rename_one('file1', 'dir1/file1')
 
404
        old_tree = self.b.repository.revision_tree('rev-1')
 
405
        new_tree = self.b.repository.revision_tree('rev-4')
 
406
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
 
407
                            working_tree=self.wt)
 
408
        self.assertContainsRe(out, 'file1\t')
 
409
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
 
410
                            working_tree=self.wt)
 
411
        self.assertNotContainsRe(out, 'file1\t')
 
412
 
 
413
 
 
414
 
 
415
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
416
    """Direct tests for show_diff_trees"""
 
417
 
 
418
    def test_modified_file(self):
 
419
        """Test when a file is modified."""
 
420
        tree = self.make_branch_and_tree('tree')
 
421
        self.build_tree_contents([('tree/file', 'contents\n')])
 
422
        tree.add(['file'], ['file-id'])
 
423
        tree.commit('one', rev_id='rev-1')
 
424
 
 
425
        self.build_tree_contents([('tree/file', 'new contents\n')])
 
426
        diff = self.get_diff(tree.basis_tree(), tree)
 
427
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
428
        self.assertContainsRe(diff, '--- old/file\t')
 
429
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
430
        self.assertContainsRe(diff, '-contents\n'
 
431
                                    '\\+new contents\n')
 
432
 
 
433
    def test_modified_file_in_renamed_dir(self):
 
434
        """Test when a file is modified in a renamed directory."""
 
435
        tree = self.make_branch_and_tree('tree')
 
436
        self.build_tree(['tree/dir/'])
 
437
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
438
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
439
        tree.commit('one', rev_id='rev-1')
 
440
 
 
441
        tree.rename_one('dir', 'other')
 
442
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
 
443
        diff = self.get_diff(tree.basis_tree(), tree)
 
444
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
445
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
 
446
        # XXX: This is technically incorrect, because it used to be at another
 
447
        # location. What to do?
 
448
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
449
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
450
        self.assertContainsRe(diff, '-contents\n'
 
451
                                    '\\+new contents\n')
 
452
 
 
453
    def test_renamed_directory(self):
 
454
        """Test when only a directory is only renamed."""
 
455
        tree = self.make_branch_and_tree('tree')
 
456
        self.build_tree(['tree/dir/'])
 
457
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
458
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
459
        tree.commit('one', rev_id='rev-1')
 
460
 
 
461
        tree.rename_one('dir', 'newdir')
 
462
        diff = self.get_diff(tree.basis_tree(), tree)
 
463
        # Renaming a directory should be a single "you renamed this dir" even
 
464
        # when there are files inside.
 
465
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
 
466
 
 
467
    def test_renamed_file(self):
 
468
        """Test when a file is only renamed."""
 
469
        tree = self.make_branch_and_tree('tree')
 
470
        self.build_tree_contents([('tree/file', 'contents\n')])
 
471
        tree.add(['file'], ['file-id'])
 
472
        tree.commit('one', rev_id='rev-1')
 
473
 
 
474
        tree.rename_one('file', 'newname')
 
475
        diff = self.get_diff(tree.basis_tree(), tree)
 
476
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
477
        # We shouldn't have a --- or +++ line, because there is no content
 
478
        # change
 
479
        self.assertNotContainsRe(diff, '---')
 
480
 
 
481
    def test_renamed_and_modified_file(self):
 
482
        """Test when a file is only renamed."""
 
483
        tree = self.make_branch_and_tree('tree')
 
484
        self.build_tree_contents([('tree/file', 'contents\n')])
 
485
        tree.add(['file'], ['file-id'])
 
486
        tree.commit('one', rev_id='rev-1')
 
487
 
 
488
        tree.rename_one('file', 'newname')
 
489
        self.build_tree_contents([('tree/newname', 'new contents\n')])
 
490
        diff = self.get_diff(tree.basis_tree(), tree)
 
491
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
492
        self.assertContainsRe(diff, '--- old/file\t')
 
493
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
494
        self.assertContainsRe(diff, '-contents\n'
 
495
                                    '\\+new contents\n')
 
496
 
 
497
 
 
498
    def test_internal_diff_exec_property(self):
 
499
        tree = self.make_branch_and_tree('tree')
 
500
 
 
501
        tt = transform.TreeTransform(tree)
 
502
        tt.new_file('a', tt.root, 'contents\n', 'a-id', True)
 
503
        tt.new_file('b', tt.root, 'contents\n', 'b-id', False)
 
504
        tt.new_file('c', tt.root, 'contents\n', 'c-id', True)
 
505
        tt.new_file('d', tt.root, 'contents\n', 'd-id', False)
 
506
        tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)
 
507
        tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)
 
508
        tt.apply()
 
509
        tree.commit('one', rev_id='rev-1')
 
510
 
 
511
        tt = transform.TreeTransform(tree)
 
512
        tt.set_executability(False, tt.trans_id_file_id('a-id'))
 
513
        tt.set_executability(True, tt.trans_id_file_id('b-id'))
 
514
        tt.set_executability(False, tt.trans_id_file_id('c-id'))
 
515
        tt.set_executability(True, tt.trans_id_file_id('d-id'))
 
516
        tt.apply()
 
517
        tree.rename_one('c', 'new-c')
 
518
        tree.rename_one('d', 'new-d')
 
519
 
 
520
        diff = self.get_diff(tree.basis_tree(), tree)
 
521
 
 
522
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
523
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
524
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
525
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
526
        self.assertNotContainsRe(diff, r"file 'e'")
 
527
        self.assertNotContainsRe(diff, r"file 'f'")
 
528
 
 
529
 
 
530
    def test_binary_unicode_filenames(self):
 
531
        """Test that contents of files are *not* encoded in UTF-8 when there
 
532
        is a binary file in the diff.
 
533
        """
 
534
        # See https://bugs.launchpad.net/bugs/110092.
 
535
        self.requireFeature(tests.UnicodeFilenameFeature)
 
536
 
 
537
        # This bug isn't triggered with cStringIO.
 
538
        from StringIO import StringIO
 
539
        tree = self.make_branch_and_tree('tree')
 
540
        alpha, omega = u'\u03b1', u'\u03c9'
 
541
        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')
 
542
        self.build_tree_contents(
 
543
            [('tree/' + alpha, chr(0)),
 
544
             ('tree/' + omega,
 
545
              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])
 
546
        tree.add([alpha], ['file-id'])
 
547
        tree.add([omega], ['file-id-2'])
 
548
        diff_content = StringIO()
 
549
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
550
        diff = diff_content.getvalue()
 
551
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
552
        self.assertContainsRe(
 
553
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
554
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
555
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
556
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
 
557
 
 
558
    def test_unicode_filename(self):
 
559
        """Test when the filename are unicode."""
 
560
        self.requireFeature(tests.UnicodeFilenameFeature)
 
561
 
 
562
        alpha, omega = u'\u03b1', u'\u03c9'
 
563
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
 
564
 
 
565
        tree = self.make_branch_and_tree('tree')
 
566
        self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])
 
567
        tree.add(['ren_'+alpha], ['file-id-2'])
 
568
        self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])
 
569
        tree.add(['del_'+alpha], ['file-id-3'])
 
570
        self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])
 
571
        tree.add(['mod_'+alpha], ['file-id-4'])
 
572
 
 
573
        tree.commit('one', rev_id='rev-1')
 
574
 
 
575
        tree.rename_one('ren_'+alpha, 'ren_'+omega)
 
576
        tree.remove('del_'+alpha)
 
577
        self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])
 
578
        tree.add(['add_'+alpha], ['file-id'])
 
579
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
 
580
 
 
581
        diff = self.get_diff(tree.basis_tree(), tree)
 
582
        self.assertContainsRe(diff,
 
583
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
 
584
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
585
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
586
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
587
 
 
588
 
 
589
class DiffWasIs(DiffPath):
 
590
 
 
591
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
592
        self.to_file.write('was: ')
 
593
        self.to_file.write(self.old_tree.get_file(file_id).read())
 
594
        self.to_file.write('is: ')
 
595
        self.to_file.write(self.new_tree.get_file(file_id).read())
 
596
        pass
 
597
 
 
598
 
 
599
class TestDiffTree(TestCaseWithTransport):
 
600
 
 
601
    def setUp(self):
 
602
        TestCaseWithTransport.setUp(self)
 
603
        self.old_tree = self.make_branch_and_tree('old-tree')
 
604
        self.old_tree.lock_write()
 
605
        self.addCleanup(self.old_tree.unlock)
 
606
        self.new_tree = self.make_branch_and_tree('new-tree')
 
607
        self.new_tree.lock_write()
 
608
        self.addCleanup(self.new_tree.unlock)
 
609
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
 
610
 
 
611
    def test_diff_text(self):
 
612
        self.build_tree_contents([('old-tree/olddir/',),
 
613
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
614
        self.old_tree.add('olddir')
 
615
        self.old_tree.add('olddir/oldfile', 'file-id')
 
616
        self.build_tree_contents([('new-tree/newdir/',),
 
617
                                  ('new-tree/newdir/newfile', 'new\n')])
 
618
        self.new_tree.add('newdir')
 
619
        self.new_tree.add('newdir/newfile', 'file-id')
 
620
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
 
621
        differ.diff_text('file-id', None, 'old label', 'new label')
 
622
        self.assertEqual(
 
623
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
 
624
            differ.to_file.getvalue())
 
625
        differ.to_file.seek(0)
 
626
        differ.diff_text(None, 'file-id', 'old label', 'new label')
 
627
        self.assertEqual(
 
628
            '--- old label\n+++ new label\n@@ -0,0 +1,1 @@\n+new\n\n',
 
629
            differ.to_file.getvalue())
 
630
        differ.to_file.seek(0)
 
631
        differ.diff_text('file-id', 'file-id', 'old label', 'new label')
 
632
        self.assertEqual(
 
633
            '--- old label\n+++ new label\n@@ -1,1 +1,1 @@\n-old\n+new\n\n',
 
634
            differ.to_file.getvalue())
 
635
 
 
636
    def test_diff_deletion(self):
 
637
        self.build_tree_contents([('old-tree/file', 'contents'),
 
638
                                  ('new-tree/file', 'contents')])
 
639
        self.old_tree.add('file', 'file-id')
 
640
        self.new_tree.add('file', 'file-id')
 
641
        os.unlink('new-tree/file')
 
642
        self.differ.show_diff(None)
 
643
        self.assertContainsRe(self.differ.to_file.getvalue(), '-contents')
 
644
 
 
645
    def test_diff_creation(self):
 
646
        self.build_tree_contents([('old-tree/file', 'contents'),
 
647
                                  ('new-tree/file', 'contents')])
 
648
        self.old_tree.add('file', 'file-id')
 
649
        self.new_tree.add('file', 'file-id')
 
650
        os.unlink('old-tree/file')
 
651
        self.differ.show_diff(None)
 
652
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
 
653
 
 
654
    def test_diff_symlink(self):
 
655
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
656
        differ.diff_symlink('old target', None)
 
657
        self.assertEqual("=== target was 'old target'\n",
 
658
                         differ.to_file.getvalue())
 
659
 
 
660
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
661
        differ.diff_symlink(None, 'new target')
 
662
        self.assertEqual("=== target is 'new target'\n",
 
663
                         differ.to_file.getvalue())
 
664
 
 
665
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
666
        differ.diff_symlink('old target', 'new target')
 
667
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
 
668
                         differ.to_file.getvalue())
 
669
 
 
670
    def test_diff(self):
 
671
        self.build_tree_contents([('old-tree/olddir/',),
 
672
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
673
        self.old_tree.add('olddir')
 
674
        self.old_tree.add('olddir/oldfile', 'file-id')
 
675
        self.build_tree_contents([('new-tree/newdir/',),
 
676
                                  ('new-tree/newdir/newfile', 'new\n')])
 
677
        self.new_tree.add('newdir')
 
678
        self.new_tree.add('newdir/newfile', 'file-id')
 
679
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
680
        self.assertContainsRe(
 
681
            self.differ.to_file.getvalue(),
 
682
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
683
             ' \@\@\n-old\n\+new\n\n')
 
684
 
 
685
    def test_diff_kind_change(self):
 
686
        self.requireFeature(tests.SymlinkFeature)
 
687
        self.build_tree_contents([('old-tree/olddir/',),
 
688
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
689
        self.old_tree.add('olddir')
 
690
        self.old_tree.add('olddir/oldfile', 'file-id')
 
691
        self.build_tree(['new-tree/newdir/'])
 
692
        os.symlink('new', 'new-tree/newdir/newfile')
 
693
        self.new_tree.add('newdir')
 
694
        self.new_tree.add('newdir/newfile', 'file-id')
 
695
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
696
        self.assertContainsRe(
 
697
            self.differ.to_file.getvalue(),
 
698
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
 
699
             ' \@\@\n-old\n\n')
 
700
        self.assertContainsRe(self.differ.to_file.getvalue(),
 
701
                              "=== target is u'new'\n")
 
702
 
 
703
    def test_diff_directory(self):
 
704
        self.build_tree(['new-tree/new-dir/'])
 
705
        self.new_tree.add('new-dir', 'new-dir-id')
 
706
        self.differ.diff('new-dir-id', None, 'new-dir')
 
707
        self.assertEqual(self.differ.to_file.getvalue(), '')
 
708
 
 
709
    def create_old_new(self):
 
710
        self.build_tree_contents([('old-tree/olddir/',),
 
711
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
712
        self.old_tree.add('olddir')
 
713
        self.old_tree.add('olddir/oldfile', 'file-id')
 
714
        self.build_tree_contents([('new-tree/newdir/',),
 
715
                                  ('new-tree/newdir/newfile', 'new\n')])
 
716
        self.new_tree.add('newdir')
 
717
        self.new_tree.add('newdir/newfile', 'file-id')
 
718
 
 
719
    def test_register_diff(self):
 
720
        self.create_old_new()
 
721
        old_diff_factories = DiffTree.diff_factories
 
722
        DiffTree.diff_factories=old_diff_factories[:]
 
723
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
724
        try:
 
725
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
 
726
        finally:
 
727
            DiffTree.diff_factories = old_diff_factories
 
728
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
729
        self.assertNotContainsRe(
 
730
            differ.to_file.getvalue(),
 
731
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
732
             ' \@\@\n-old\n\+new\n\n')
 
733
        self.assertContainsRe(differ.to_file.getvalue(),
 
734
                              'was: old\nis: new\n')
 
735
 
 
736
    def test_extra_factories(self):
 
737
        self.create_old_new()
 
738
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
739
                            extra_factories=[DiffWasIs.from_diff_tree])
 
740
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
741
        self.assertNotContainsRe(
 
742
            differ.to_file.getvalue(),
 
743
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
744
             ' \@\@\n-old\n\+new\n\n')
 
745
        self.assertContainsRe(differ.to_file.getvalue(),
 
746
                              'was: old\nis: new\n')
 
747
 
 
748
    def test_alphabetical_order(self):
 
749
        self.build_tree(['new-tree/a-file'])
 
750
        self.new_tree.add('a-file')
 
751
        self.build_tree(['old-tree/b-file'])
 
752
        self.old_tree.add('b-file')
 
753
        self.differ.show_diff(None)
 
754
        self.assertContainsRe(self.differ.to_file.getvalue(),
 
755
            '.*a-file(.|\n)*b-file')
 
756
 
278
757
 
279
758
class TestPatienceDiffLib(TestCase):
280
759
 
 
760
    def setUp(self):
 
761
        super(TestPatienceDiffLib, self).setUp()
 
762
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
763
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
 
764
        self._PatienceSequenceMatcher = \
 
765
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
 
766
 
 
767
    def test_diff_unicode_string(self):
 
768
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
 
769
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
 
770
        sm = self._PatienceSequenceMatcher(None, a, b)
 
771
        mb = sm.get_matching_blocks()
 
772
        self.assertEquals(35, len(mb))
 
773
 
281
774
    def test_unique_lcs(self):
282
 
        unique_lcs = bzrlib.patiencediff.unique_lcs
 
775
        unique_lcs = self._unique_lcs
283
776
        self.assertEquals(unique_lcs('', ''), [])
 
777
        self.assertEquals(unique_lcs('', 'a'), [])
 
778
        self.assertEquals(unique_lcs('a', ''), [])
284
779
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
285
780
        self.assertEquals(unique_lcs('a', 'b'), [])
286
781
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
287
782
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
288
783
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
289
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
 
784
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
290
785
                                                         (3,3), (4,4)])
291
786
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
292
787
 
293
788
    def test_recurse_matches(self):
294
789
        def test_one(a, b, matches):
295
790
            test_matches = []
296
 
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
297
 
                test_matches, 10)
 
791
            self._recurse_matches(
 
792
                a, b, 0, 0, len(a), len(b), test_matches, 10)
298
793
            self.assertEquals(test_matches, matches)
299
794
 
300
795
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
301
796
                 [(0, 0), (2, 2), (4, 4)])
302
797
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
303
798
                 [(0, 0), (2, 1), (4, 2)])
 
799
        # Even though 'bc' is not unique globally, and is surrounded by
 
800
        # non-matching lines, we should still match, because they are locally
 
801
        # unique
 
802
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
 
803
                                          (4, 6), (5, 7), (6, 8)])
304
804
 
305
 
        # recurse_matches doesn't match non-unique 
 
805
        # recurse_matches doesn't match non-unique
306
806
        # lines surrounded by bogus text.
307
807
        # The update has been done in patiencediff.SequenceMatcher instead
308
808
 
312
812
        # This is what it currently gives:
313
813
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
314
814
 
 
815
    def assertDiffBlocks(self, a, b, expected_blocks):
 
816
        """Check that the sequence matcher returns the correct blocks.
 
817
 
 
818
        :param a: A sequence to match
 
819
        :param b: Another sequence to match
 
820
        :param expected_blocks: The expected output, not including the final
 
821
            matching block (len(a), len(b), 0)
 
822
        """
 
823
        matcher = self._PatienceSequenceMatcher(None, a, b)
 
824
        blocks = matcher.get_matching_blocks()
 
825
        last = blocks.pop()
 
826
        self.assertEqual((len(a), len(b), 0), last)
 
827
        self.assertEqual(expected_blocks, blocks)
 
828
 
315
829
    def test_matching_blocks(self):
316
 
        def chk_blocks(a, b, expected_blocks):
317
 
            # difflib always adds a signature of the total
318
 
            # length, with no matching entries at the end
319
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
320
 
            blocks = s.get_matching_blocks()
321
 
            self.assertEquals((len(a), len(b), 0), blocks[-1])
322
 
            self.assertEquals(expected_blocks, blocks[:-1])
323
 
 
324
830
        # Some basic matching tests
325
 
        chk_blocks('', '', [])
326
 
        chk_blocks([], [], [])
327
 
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
328
 
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
329
 
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
330
 
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
331
 
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
332
 
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
333
 
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
334
 
        # This may check too much, but it checks to see that 
 
831
        self.assertDiffBlocks('', '', [])
 
832
        self.assertDiffBlocks([], [], [])
 
833
        self.assertDiffBlocks('abc', '', [])
 
834
        self.assertDiffBlocks('', 'abc', [])
 
835
        self.assertDiffBlocks('abcd', 'abcd', [(0, 0, 4)])
 
836
        self.assertDiffBlocks('abcd', 'abce', [(0, 0, 3)])
 
837
        self.assertDiffBlocks('eabc', 'abce', [(1, 0, 3)])
 
838
        self.assertDiffBlocks('eabce', 'abce', [(1, 0, 4)])
 
839
        self.assertDiffBlocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
 
840
        self.assertDiffBlocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
 
841
        self.assertDiffBlocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
 
842
        # This may check too much, but it checks to see that
335
843
        # a copied block stays attached to the previous section,
336
844
        # not the later one.
337
845
        # difflib would tend to grab the trailing longest match
338
846
        # which would make the diff not look right
339
 
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
340
 
                   [(0, 0, 6), (6, 11, 10)])
 
847
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
848
                              [(0, 0, 6), (6, 11, 10)])
341
849
 
342
850
        # make sure it supports passing in lists
343
 
        chk_blocks(
 
851
        self.assertDiffBlocks(
344
852
                   ['hello there\n',
345
853
                    'world\n',
346
854
                    'how are you today?\n'],
350
858
 
351
859
        # non unique lines surrounded by non-matching lines
352
860
        # won't be found
353
 
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
861
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
354
862
 
355
863
        # But they only need to be locally unique
356
 
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
864
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
357
865
 
358
866
        # non unique blocks won't be matched
359
 
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
867
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
360
868
 
361
869
        # but locally unique ones will
362
 
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
870
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
363
871
                                              (5,4,1), (7,5,2), (10,8,1)])
364
872
 
365
 
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
366
 
        chk_blocks('abbabbbb', 'cabbabbc', [])
367
 
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
 
873
        self.assertDiffBlocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
874
        self.assertDiffBlocks('abbabbbb', 'cabbabbc', [])
 
875
        self.assertDiffBlocks('bbbbbbbb', 'cbbbbbbc', [])
 
876
 
 
877
    def test_matching_blocks_tuples(self):
 
878
        # Some basic matching tests
 
879
        self.assertDiffBlocks([], [], [])
 
880
        self.assertDiffBlocks([('a',), ('b',), ('c,')], [], [])
 
881
        self.assertDiffBlocks([], [('a',), ('b',), ('c,')], [])
 
882
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
 
883
                              [('a',), ('b',), ('c,')],
 
884
                              [(0, 0, 3)])
 
885
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
 
886
                              [('a',), ('b',), ('d,')],
 
887
                              [(0, 0, 2)])
 
888
        self.assertDiffBlocks([('d',), ('b',), ('c,')],
 
889
                              [('a',), ('b',), ('c,')],
 
890
                              [(1, 1, 2)])
 
891
        self.assertDiffBlocks([('d',), ('a',), ('b',), ('c,')],
 
892
                              [('a',), ('b',), ('c,')],
 
893
                              [(1, 0, 3)])
 
894
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
 
895
                              [('a', 'b'), ('c', 'X'), ('e', 'f')],
 
896
                              [(0, 0, 1), (2, 2, 1)])
 
897
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
 
898
                              [('a', 'b'), ('c', 'dX'), ('e', 'f')],
 
899
                              [(0, 0, 1), (2, 2, 1)])
368
900
 
369
901
    def test_opcodes(self):
370
902
        def chk_ops(a, b, expected_codes):
371
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
903
            s = self._PatienceSequenceMatcher(None, a, b)
372
904
            self.assertEquals(expected_codes, s.get_opcodes())
373
905
 
374
906
        chk_ops('', '', [])
375
907
        chk_ops([], [], [])
 
908
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
 
909
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
376
910
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
377
911
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
378
912
                                 ('replace', 3,4, 3,4)
411
945
                 ('delete', 1,2, 1,1),
412
946
                 ('equal',  2,3, 1,2),
413
947
                ])
414
 
        chk_ops('aBccDe', 'abccde', 
 
948
        chk_ops('aBccDe', 'abccde',
415
949
                [('equal',   0,1, 0,1),
416
950
                 ('replace', 1,5, 1,5),
417
951
                 ('equal',   5,6, 5,6),
418
952
                ])
419
 
        chk_ops('aBcDec', 'abcdec', 
 
953
        chk_ops('aBcDec', 'abcdec',
420
954
                [('equal',   0,1, 0,1),
421
955
                 ('replace', 1,2, 1,2),
422
956
                 ('equal',   2,3, 2,3),
423
957
                 ('replace', 3,4, 3,4),
424
958
                 ('equal',   4,6, 4,6),
425
959
                ])
426
 
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
 
960
        chk_ops('aBcdEcdFg', 'abcdecdfg',
427
961
                [('equal',   0,1, 0,1),
428
962
                 ('replace', 1,8, 1,8),
429
963
                 ('equal',   8,9, 8,9)
430
964
                ])
431
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
965
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
432
966
                [('equal',   0,1, 0,1),
433
967
                 ('replace', 1,2, 1,2),
434
968
                 ('equal',   2,4, 2,4),
440
974
                 ('equal',   10,11, 8,9)
441
975
                ])
442
976
 
 
977
    def test_grouped_opcodes(self):
 
978
        def chk_ops(a, b, expected_codes, n=3):
 
979
            s = self._PatienceSequenceMatcher(None, a, b)
 
980
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
 
981
 
 
982
        chk_ops('', '', [])
 
983
        chk_ops([], [], [])
 
984
        chk_ops('abc', '', [[('delete', 0,3, 0,0)]])
 
985
        chk_ops('', 'abc', [[('insert', 0,0, 0,3)]])
 
986
        chk_ops('abcd', 'abcd', [])
 
987
        chk_ops('abcd', 'abce', [[('equal',   0,3, 0,3),
 
988
                                  ('replace', 3,4, 3,4)
 
989
                                 ]])
 
990
        chk_ops('eabc', 'abce', [[('delete', 0,1, 0,0),
 
991
                                 ('equal',  1,4, 0,3),
 
992
                                 ('insert', 4,4, 3,4)
 
993
                                ]])
 
994
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
995
                [[('equal',  3,6, 3,6),
 
996
                  ('insert', 6,6, 6,11),
 
997
                  ('equal',  6,9, 11,14)
 
998
                  ]])
 
999
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
1000
                [[('equal',  2,6, 2,6),
 
1001
                  ('insert', 6,6, 6,11),
 
1002
                  ('equal',  6,10, 11,15)
 
1003
                  ]], 4)
 
1004
        chk_ops('Xabcdef', 'abcdef',
 
1005
                [[('delete', 0,1, 0,0),
 
1006
                  ('equal',  1,4, 0,3)
 
1007
                  ]])
 
1008
        chk_ops('abcdef', 'abcdefX',
 
1009
                [[('equal',  3,6, 3,6),
 
1010
                  ('insert', 6,6, 6,7)
 
1011
                  ]])
 
1012
 
 
1013
 
443
1014
    def test_multiple_ranges(self):
444
1015
        # There was an earlier bug where we used a bad set of ranges,
445
1016
        # this triggers that specific bug, to make sure it doesn't regress
446
 
        def chk_blocks(a, b, expected_blocks):
447
 
            # difflib always adds a signature of the total
448
 
            # length, with no matching entries at the end
449
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
450
 
            blocks = s.get_matching_blocks()
451
 
            x = blocks.pop()
452
 
            self.assertEquals(x, (len(a), len(b), 0))
453
 
            self.assertEquals(expected_blocks, blocks)
454
 
 
455
 
        chk_blocks('abcdefghijklmnop'
456
 
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
457
 
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
458
 
 
459
 
        chk_blocks('ABCd efghIjk  L'
460
 
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
461
 
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
 
1017
        self.assertDiffBlocks('abcdefghijklmnop',
 
1018
                              'abcXghiYZQRSTUVWXYZijklmnop',
 
1019
                              [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
 
1020
 
 
1021
        self.assertDiffBlocks('ABCd efghIjk  L',
 
1022
                              'AxyzBCn mo pqrstuvwI1 2  L',
 
1023
                              [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
462
1024
 
463
1025
        # These are rot13 code snippets.
464
 
        chk_blocks('''\
 
1026
        self.assertDiffBlocks('''\
465
1027
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
466
1028
    """
467
1029
    gnxrf_netf = ['svyr*']
468
1030
    gnxrf_bcgvbaf = ['ab-erphefr']
469
 
  
 
1031
 
470
1032
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
471
1033
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
472
1034
        vs vf_dhvrg():
480
1042
'''.splitlines(True), '''\
481
1043
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
482
1044
 
483
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
 
1045
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
484
1046
    nqq gurz.
485
1047
    """
486
1048
    gnxrf_netf = ['svyr*']
514
1076
        txt_b = ['hello there\n',
515
1077
                 'how are you today?\n']
516
1078
        unified_diff = bzrlib.patiencediff.unified_diff
517
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
518
 
        self.assertEquals([ '---  \n',
519
 
                           '+++  \n',
 
1079
        psm = self._PatienceSequenceMatcher
 
1080
        self.assertEquals(['--- \n',
 
1081
                           '+++ \n',
520
1082
                           '@@ -1,3 +1,2 @@\n',
521
1083
                           ' hello there\n',
522
1084
                           '-world\n',
527
1089
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
528
1090
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
529
1091
        # This is the result with LongestCommonSubstring matching
530
 
        self.assertEquals(['---  \n',
531
 
                           '+++  \n',
 
1092
        self.assertEquals(['--- \n',
 
1093
                           '+++ \n',
532
1094
                           '@@ -1,6 +1,11 @@\n',
533
1095
                           ' a\n',
534
1096
                           ' b\n',
543
1105
                           ' f\n']
544
1106
                          , list(unified_diff(txt_a, txt_b)))
545
1107
        # And the patience diff
546
 
        self.assertEquals(['---  \n',
547
 
                           '+++  \n',
 
1108
        self.assertEquals(['--- \n',
 
1109
                           '+++ \n',
548
1110
                           '@@ -4,6 +4,11 @@\n',
549
1111
                           ' d\n',
550
1112
                           ' e\n',
561
1123
                          , list(unified_diff(txt_a, txt_b,
562
1124
                                 sequencematcher=psm)))
563
1125
 
 
1126
    def test_patience_unified_diff_with_dates(self):
 
1127
        txt_a = ['hello there\n',
 
1128
                 'world\n',
 
1129
                 'how are you today?\n']
 
1130
        txt_b = ['hello there\n',
 
1131
                 'how are you today?\n']
 
1132
        unified_diff = bzrlib.patiencediff.unified_diff
 
1133
        psm = self._PatienceSequenceMatcher
 
1134
        self.assertEquals(['--- a\t2008-08-08\n',
 
1135
                           '+++ b\t2008-09-09\n',
 
1136
                           '@@ -1,3 +1,2 @@\n',
 
1137
                           ' hello there\n',
 
1138
                           '-world\n',
 
1139
                           ' how are you today?\n'
 
1140
                          ]
 
1141
                          , list(unified_diff(txt_a, txt_b,
 
1142
                                 fromfile='a', tofile='b',
 
1143
                                 fromfiledate='2008-08-08',
 
1144
                                 tofiledate='2008-09-09',
 
1145
                                 sequencematcher=psm)))
 
1146
 
 
1147
 
 
1148
class TestPatienceDiffLib_c(TestPatienceDiffLib):
 
1149
 
 
1150
    _test_needs_features = [compiled_patiencediff_feature]
 
1151
 
 
1152
    def setUp(self):
 
1153
        super(TestPatienceDiffLib_c, self).setUp()
 
1154
        import bzrlib._patiencediff_c
 
1155
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1156
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
 
1157
        self._PatienceSequenceMatcher = \
 
1158
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1159
 
 
1160
    def test_unhashable(self):
 
1161
        """We should get a proper exception here."""
 
1162
        # We need to be able to hash items in the sequence, lists are
 
1163
        # unhashable, and thus cannot be diffed
 
1164
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1165
                                         None, [[]], [])
 
1166
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1167
                                         None, ['valid', []], [])
 
1168
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1169
                                         None, ['valid'], [[]])
 
1170
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1171
                                         None, ['valid'], ['valid', []])
 
1172
 
564
1173
 
565
1174
class TestPatienceDiffLibFiles(TestCaseInTempDir):
566
1175
 
 
1176
    def setUp(self):
 
1177
        super(TestPatienceDiffLibFiles, self).setUp()
 
1178
        self._PatienceSequenceMatcher = \
 
1179
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
 
1180
 
567
1181
    def test_patience_unified_diff_files(self):
568
1182
        txt_a = ['hello there\n',
569
1183
                 'world\n',
574
1188
        open('b1', 'wb').writelines(txt_b)
575
1189
 
576
1190
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
577
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
578
 
        self.assertEquals(['--- a1 \n',
579
 
                           '+++ b1 \n',
 
1191
        psm = self._PatienceSequenceMatcher
 
1192
        self.assertEquals(['--- a1\n',
 
1193
                           '+++ b1\n',
580
1194
                           '@@ -1,3 +1,2 @@\n',
581
1195
                           ' hello there\n',
582
1196
                           '-world\n',
591
1205
        open('b2', 'wb').writelines(txt_b)
592
1206
 
593
1207
        # This is the result with LongestCommonSubstring matching
594
 
        self.assertEquals(['--- a2 \n',
595
 
                           '+++ b2 \n',
 
1208
        self.assertEquals(['--- a2\n',
 
1209
                           '+++ b2\n',
596
1210
                           '@@ -1,6 +1,11 @@\n',
597
1211
                           ' a\n',
598
1212
                           ' b\n',
608
1222
                          , list(unified_diff_files('a2', 'b2')))
609
1223
 
610
1224
        # And the patience diff
611
 
        self.assertEquals(['--- a2 \n',
612
 
                           '+++ b2 \n',
 
1225
        self.assertEquals(['--- a2\n',
 
1226
                           '+++ b2\n',
613
1227
                           '@@ -4,6 +4,11 @@\n',
614
1228
                           ' d\n',
615
1229
                           ' e\n',
625
1239
                          ]
626
1240
                          , list(unified_diff_files('a2', 'b2',
627
1241
                                 sequencematcher=psm)))
 
1242
 
 
1243
 
 
1244
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
 
1245
 
 
1246
    _test_needs_features = [compiled_patiencediff_feature]
 
1247
 
 
1248
    def setUp(self):
 
1249
        super(TestPatienceDiffLibFiles_c, self).setUp()
 
1250
        import bzrlib._patiencediff_c
 
1251
        self._PatienceSequenceMatcher = \
 
1252
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1253
 
 
1254
 
 
1255
class TestUsingCompiledIfAvailable(TestCase):
 
1256
 
 
1257
    def test_PatienceSequenceMatcher(self):
 
1258
        if compiled_patiencediff_feature.available():
 
1259
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
 
1260
            self.assertIs(PatienceSequenceMatcher_c,
 
1261
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
1262
        else:
 
1263
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
 
1264
            self.assertIs(PatienceSequenceMatcher_py,
 
1265
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
1266
 
 
1267
    def test_unique_lcs(self):
 
1268
        if compiled_patiencediff_feature.available():
 
1269
            from bzrlib._patiencediff_c import unique_lcs_c
 
1270
            self.assertIs(unique_lcs_c,
 
1271
                          bzrlib.patiencediff.unique_lcs)
 
1272
        else:
 
1273
            from bzrlib._patiencediff_py import unique_lcs_py
 
1274
            self.assertIs(unique_lcs_py,
 
1275
                          bzrlib.patiencediff.unique_lcs)
 
1276
 
 
1277
    def test_recurse_matches(self):
 
1278
        if compiled_patiencediff_feature.available():
 
1279
            from bzrlib._patiencediff_c import recurse_matches_c
 
1280
            self.assertIs(recurse_matches_c,
 
1281
                          bzrlib.patiencediff.recurse_matches)
 
1282
        else:
 
1283
            from bzrlib._patiencediff_py import recurse_matches_py
 
1284
            self.assertIs(recurse_matches_py,
 
1285
                          bzrlib.patiencediff.recurse_matches)
 
1286
 
 
1287
 
 
1288
class TestDiffFromTool(TestCaseWithTransport):
 
1289
 
 
1290
    def test_from_string(self):
 
1291
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
 
1292
        self.addCleanup(diff_obj.finish)
 
1293
        self.assertEqual(['diff', '@old_path', '@new_path'],
 
1294
            diff_obj.command_template)
 
1295
 
 
1296
    def test_from_string_u5(self):
 
1297
        diff_obj = DiffFromTool.from_string('diff "-u 5"', None, None, None)
 
1298
        self.addCleanup(diff_obj.finish)
 
1299
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
 
1300
                         diff_obj.command_template)
 
1301
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
 
1302
                         diff_obj._get_command('old-path', 'new-path'))
 
1303
        
 
1304
    def test_from_string_path_with_backslashes(self):
 
1305
        self.requireFeature(BackslashDirSeparatorFeature)
 
1306
        tool = 'C:\\Tools\\Diff.exe'
 
1307
        diff_obj = DiffFromTool.from_string(tool, None, None, None)
 
1308
        self.addCleanup(diff_obj.finish)
 
1309
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
 
1310
                         diff_obj.command_template)
 
1311
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
 
1312
                         diff_obj._get_command('old-path', 'new-path'))
 
1313
 
 
1314
    def test_execute(self):
 
1315
        output = StringIO()
 
1316
        diff_obj = DiffFromTool(['python', '-c',
 
1317
                                 'print "@old_path @new_path"'],
 
1318
                                None, None, output)
 
1319
        self.addCleanup(diff_obj.finish)
 
1320
        diff_obj._execute('old', 'new')
 
1321
        self.assertEqual(output.getvalue().rstrip(), 'old new')
 
1322
 
 
1323
    def test_excute_missing(self):
 
1324
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1325
                                None, None, None)
 
1326
        self.addCleanup(diff_obj.finish)
 
1327
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1328
                              'new')
 
1329
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
 
1330
                         ' on this machine', str(e))
 
1331
 
 
1332
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
 
1333
        self.requireFeature(AttribFeature)
 
1334
        output = StringIO()
 
1335
        tree = self.make_branch_and_tree('tree')
 
1336
        self.build_tree_contents([('tree/file', 'content')])
 
1337
        tree.add('file', 'file-id')
 
1338
        tree.commit('old tree')
 
1339
        tree.lock_read()
 
1340
        self.addCleanup(tree.unlock)
 
1341
        basis_tree = tree.basis_tree()
 
1342
        basis_tree.lock_read()
 
1343
        self.addCleanup(basis_tree.unlock)
 
1344
        diff_obj = DiffFromTool(['python', '-c',
 
1345
                                 'print "@old_path @new_path"'],
 
1346
                                basis_tree, tree, output)
 
1347
        diff_obj._prepare_files('file-id', 'file', 'file')
 
1348
        # The old content should be readonly
 
1349
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
 
1350
                                    r'R.*old\\file$')
 
1351
        # The new content should use the tree object, not a 'new' file anymore
 
1352
        self.assertEndsWith(tree.basedir, 'work/tree')
 
1353
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
 
1354
 
 
1355
    def assertReadableByAttrib(self, cwd, relpath, regex):
 
1356
        proc = subprocess.Popen(['attrib', relpath],
 
1357
                                stdout=subprocess.PIPE,
 
1358
                                cwd=cwd)
 
1359
        (result, err) = proc.communicate()
 
1360
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
 
1361
 
 
1362
    def test_prepare_files(self):
 
1363
        output = StringIO()
 
1364
        tree = self.make_branch_and_tree('tree')
 
1365
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
 
1366
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
 
1367
        tree.add('oldname', 'file-id')
 
1368
        tree.add('oldname2', 'file2-id')
 
1369
        tree.commit('old tree', timestamp=0)
 
1370
        tree.rename_one('oldname', 'newname')
 
1371
        tree.rename_one('oldname2', 'newname2')
 
1372
        self.build_tree_contents([('tree/newname', 'newcontent')])
 
1373
        self.build_tree_contents([('tree/newname2', 'newcontent2')])
 
1374
        old_tree = tree.basis_tree()
 
1375
        old_tree.lock_read()
 
1376
        self.addCleanup(old_tree.unlock)
 
1377
        tree.lock_read()
 
1378
        self.addCleanup(tree.unlock)
 
1379
        diff_obj = DiffFromTool(['python', '-c',
 
1380
                                 'print "@old_path @new_path"'],
 
1381
                                old_tree, tree, output)
 
1382
        self.addCleanup(diff_obj.finish)
 
1383
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
 
1384
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
 
1385
                                                     'newname')
 
1386
        self.assertContainsRe(old_path, 'old/oldname$')
 
1387
        self.assertEqual(0, os.stat(old_path).st_mtime)
 
1388
        self.assertContainsRe(new_path, 'tree/newname$')
 
1389
        self.assertFileEqual('oldcontent', old_path)
 
1390
        self.assertFileEqual('newcontent', new_path)
 
1391
        if osutils.host_os_dereferences_symlinks():
 
1392
            self.assertTrue(os.path.samefile('tree/newname', new_path))
 
1393
        # make sure we can create files with the same parent directories
 
1394
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
 
1395
 
 
1396
 
 
1397
class TestGetTreesAndBranchesToDiff(TestCaseWithTransport):
 
1398
 
 
1399
    def test_basic(self):
 
1400
        tree = self.make_branch_and_tree('tree')
 
1401
        (old_tree, new_tree,
 
1402
         old_branch, new_branch,
 
1403
         specific_files, extra_trees) = \
 
1404
            get_trees_and_branches_to_diff(['tree'], None, None, None)
 
1405
 
 
1406
        self.assertIsInstance(old_tree, RevisionTree)
 
1407
        #print dir (old_tree)
 
1408
        self.assertEqual(_mod_revision.NULL_REVISION, old_tree.get_revision_id())
 
1409
        self.assertEqual(tree.basedir, new_tree.basedir)
 
1410
        self.assertEqual(tree.branch.base, old_branch.base)
 
1411
        self.assertEqual(tree.branch.base, new_branch.base)
 
1412
        self.assertIs(None, specific_files)
 
1413
        self.assertIs(None, extra_trees)
 
1414
 
 
1415
    def test_with_rev_specs(self):
 
1416
        tree = self.make_branch_and_tree('tree')
 
1417
        self.build_tree_contents([('tree/file', 'oldcontent')])
 
1418
        tree.add('file', 'file-id')
 
1419
        tree.commit('old tree', timestamp=0, rev_id="old-id")
 
1420
        self.build_tree_contents([('tree/file', 'newcontent')])
 
1421
        tree.commit('new tree', timestamp=0, rev_id="new-id")
 
1422
 
 
1423
        revisions = [RevisionSpec.from_string('1'),
 
1424
                     RevisionSpec.from_string('2')]
 
1425
        (old_tree, new_tree,
 
1426
         old_branch, new_branch,
 
1427
         specific_files, extra_trees) = \
 
1428
            get_trees_and_branches_to_diff(['tree'], revisions, None, None)
 
1429
 
 
1430
        self.assertIsInstance(old_tree, RevisionTree)
 
1431
        self.assertEqual("old-id", old_tree.get_revision_id())
 
1432
        self.assertIsInstance(new_tree, RevisionTree)
 
1433
        self.assertEqual("new-id", new_tree.get_revision_id())
 
1434
        self.assertEqual(tree.branch.base, old_branch.base)
 
1435
        self.assertEqual(tree.branch.base, new_branch.base)
 
1436
        self.assertIs(None, specific_files)
 
1437
        self.assertEqual(tree.basedir, extra_trees[0].basedir)