← 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: Canonical.com Patch Queue Manager
  • Date: 2006-07-02 00:49:15 UTC
  • mfrom: (1706.2.8 bzr.dev.lsprof)
  • Revision ID: pqm@pqm.ubuntu.com-20060702004915-501855cc9fc14e10
(robey) updates for lsprof

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Development 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import os
18
 
import os.path
19
18
from cStringIO import StringIO
20
19
import errno
21
 
import subprocess
22
 
import sys
23
20
from tempfile import TemporaryFile
24
21
 
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
 
22
from bzrlib.diff import internal_diff, external_diff, show_diff_trees
 
23
from bzrlib.errors import BinaryFile, NoDiff
41
24
import bzrlib.patiencediff
42
 
import bzrlib._patiencediff_py
43
 
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
25
from bzrlib.tests import (TestCase, TestCaseWithTransport,
44
26
                          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')
70
27
 
71
28
 
72
29
def udiff_lines(old, new, allow_binary=False):
142
99
    def test_external_diff(self):
143
100
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
144
101
        self.check_patch(lines)
145
 
        self.assertEqual('\n', lines[-1])
146
102
 
147
103
    def test_external_diff_no_fileno(self):
148
104
        # Make sure that we can handle not having a fileno, even
151
107
                                     ['goo\n']*10000,
152
108
                                     use_stringio=True)
153
109
        self.check_patch(lines)
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
 
 
 
110
        
182
111
    def test_internal_diff_default(self):
183
112
        # Default internal diff encoding is utf8
184
113
        output = StringIO()
227
156
                          ]
228
157
                          , lines)
229
158
 
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
 
 
242
159
    def test_internal_diff_returns_bytes(self):
243
160
        import StringIO
244
161
        output = StringIO.StringIO()
248
165
            'internal_diff should return bytestrings')
249
166
 
250
167
 
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):
 
168
class TestDiffDates(TestCaseWithTransport):
286
169
 
287
170
    def setUp(self):
288
171
        super(TestDiffDates, self).setUp()
322
205
        # set the date stamps for files in the working tree to known values
323
206
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
324
207
 
 
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
 
325
214
    def test_diff_rev_tree_working_tree(self):
326
215
        output = self.get_diff(self.wt.basis_tree(), self.wt)
327
216
        # note that the date for old/file1 is from rev 2 rather than from
349
238
+file2 contents at rev 3
350
239
 
351
240
''')
352
 
 
 
241
        
353
242
    def test_diff_add_files(self):
354
 
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
 
243
        tree1 = self.b.repository.revision_tree(None)
355
244
        tree2 = self.b.repository.revision_tree('rev-1')
356
245
        output = self.get_diff(tree1, tree2)
357
246
        # the files have the epoch time stamp for the tree in which
386
275
 
387
276
''')
388
277
 
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
 
 
757
278
 
758
279
class TestPatienceDiffLib(TestCase):
759
280
 
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
 
 
774
281
    def test_unique_lcs(self):
775
 
        unique_lcs = self._unique_lcs
 
282
        unique_lcs = bzrlib.patiencediff.unique_lcs
776
283
        self.assertEquals(unique_lcs('', ''), [])
777
 
        self.assertEquals(unique_lcs('', 'a'), [])
778
 
        self.assertEquals(unique_lcs('a', ''), [])
779
284
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
780
285
        self.assertEquals(unique_lcs('a', 'b'), [])
781
286
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
782
287
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
783
288
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
784
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
289
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
785
290
                                                         (3,3), (4,4)])
786
291
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
787
292
 
788
293
    def test_recurse_matches(self):
789
294
        def test_one(a, b, matches):
790
295
            test_matches = []
791
 
            self._recurse_matches(
792
 
                a, b, 0, 0, len(a), len(b), test_matches, 10)
 
296
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
 
297
                test_matches, 10)
793
298
            self.assertEquals(test_matches, matches)
794
299
 
795
300
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
796
301
                 [(0, 0), (2, 2), (4, 4)])
797
302
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
798
303
                 [(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)])
804
304
 
805
 
        # recurse_matches doesn't match non-unique
 
305
        # recurse_matches doesn't match non-unique 
806
306
        # lines surrounded by bogus text.
807
307
        # The update has been done in patiencediff.SequenceMatcher instead
808
308
 
812
312
        # This is what it currently gives:
813
313
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
814
314
 
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
 
 
829
315
    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
 
830
324
        # Some basic matching tests
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
 
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 
843
335
        # a copied block stays attached to the previous section,
844
336
        # not the later one.
845
337
        # difflib would tend to grab the trailing longest match
846
338
        # which would make the diff not look right
847
 
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
848
 
                              [(0, 0, 6), (6, 11, 10)])
 
339
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
340
                   [(0, 0, 6), (6, 11, 10)])
849
341
 
850
342
        # make sure it supports passing in lists
851
 
        self.assertDiffBlocks(
 
343
        chk_blocks(
852
344
                   ['hello there\n',
853
345
                    'world\n',
854
346
                    'how are you today?\n'],
858
350
 
859
351
        # non unique lines surrounded by non-matching lines
860
352
        # won't be found
861
 
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
353
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
862
354
 
863
355
        # But they only need to be locally unique
864
 
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
356
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
865
357
 
866
358
        # non unique blocks won't be matched
867
 
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
359
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
868
360
 
869
361
        # but locally unique ones will
870
 
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
362
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
871
363
                                              (5,4,1), (7,5,2), (10,8,1)])
872
364
 
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)])
 
365
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
366
        chk_blocks('abbabbbb', 'cabbabbc', [])
 
367
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
900
368
 
901
369
    def test_opcodes(self):
902
370
        def chk_ops(a, b, expected_codes):
903
 
            s = self._PatienceSequenceMatcher(None, a, b)
 
371
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
904
372
            self.assertEquals(expected_codes, s.get_opcodes())
905
373
 
906
374
        chk_ops('', '', [])
907
375
        chk_ops([], [], [])
908
 
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
909
 
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
910
376
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
911
377
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
912
378
                                 ('replace', 3,4, 3,4)
945
411
                 ('delete', 1,2, 1,1),
946
412
                 ('equal',  2,3, 1,2),
947
413
                ])
948
 
        chk_ops('aBccDe', 'abccde',
 
414
        chk_ops('aBccDe', 'abccde', 
949
415
                [('equal',   0,1, 0,1),
950
416
                 ('replace', 1,5, 1,5),
951
417
                 ('equal',   5,6, 5,6),
952
418
                ])
953
 
        chk_ops('aBcDec', 'abcdec',
 
419
        chk_ops('aBcDec', 'abcdec', 
954
420
                [('equal',   0,1, 0,1),
955
421
                 ('replace', 1,2, 1,2),
956
422
                 ('equal',   2,3, 2,3),
957
423
                 ('replace', 3,4, 3,4),
958
424
                 ('equal',   4,6, 4,6),
959
425
                ])
960
 
        chk_ops('aBcdEcdFg', 'abcdecdfg',
 
426
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
961
427
                [('equal',   0,1, 0,1),
962
428
                 ('replace', 1,8, 1,8),
963
429
                 ('equal',   8,9, 8,9)
964
430
                ])
965
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
 
431
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
966
432
                [('equal',   0,1, 0,1),
967
433
                 ('replace', 1,2, 1,2),
968
434
                 ('equal',   2,4, 2,4),
974
440
                 ('equal',   10,11, 8,9)
975
441
                ])
976
442
 
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
 
 
1014
443
    def test_multiple_ranges(self):
1015
444
        # There was an earlier bug where we used a bad set of ranges,
1016
445
        # this triggers that specific bug, to make sure it doesn't regress
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)])
 
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)])
1024
462
 
1025
463
        # These are rot13 code snippets.
1026
 
        self.assertDiffBlocks('''\
 
464
        chk_blocks('''\
1027
465
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1028
466
    """
1029
467
    gnxrf_netf = ['svyr*']
1030
468
    gnxrf_bcgvbaf = ['ab-erphefr']
1031
 
 
 
469
  
1032
470
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1033
471
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1034
472
        vs vf_dhvrg():
1042
480
'''.splitlines(True), '''\
1043
481
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1044
482
 
1045
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
 
483
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
1046
484
    nqq gurz.
1047
485
    """
1048
486
    gnxrf_netf = ['svyr*']
1076
514
        txt_b = ['hello there\n',
1077
515
                 'how are you today?\n']
1078
516
        unified_diff = bzrlib.patiencediff.unified_diff
1079
 
        psm = self._PatienceSequenceMatcher
1080
 
        self.assertEquals(['--- \n',
1081
 
                           '+++ \n',
 
517
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
518
        self.assertEquals([ '---  \n',
 
519
                           '+++  \n',
1082
520
                           '@@ -1,3 +1,2 @@\n',
1083
521
                           ' hello there\n',
1084
522
                           '-world\n',
1089
527
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1090
528
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1091
529
        # This is the result with LongestCommonSubstring matching
1092
 
        self.assertEquals(['--- \n',
1093
 
                           '+++ \n',
 
530
        self.assertEquals(['---  \n',
 
531
                           '+++  \n',
1094
532
                           '@@ -1,6 +1,11 @@\n',
1095
533
                           ' a\n',
1096
534
                           ' b\n',
1105
543
                           ' f\n']
1106
544
                          , list(unified_diff(txt_a, txt_b)))
1107
545
        # And the patience diff
1108
 
        self.assertEquals(['--- \n',
1109
 
                           '+++ \n',
 
546
        self.assertEquals(['---  \n',
 
547
                           '+++  \n',
1110
548
                           '@@ -4,6 +4,11 @@\n',
1111
549
                           ' d\n',
1112
550
                           ' e\n',
1123
561
                          , list(unified_diff(txt_a, txt_b,
1124
562
                                 sequencematcher=psm)))
1125
563
 
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
 
 
1173
564
 
1174
565
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1175
566
 
1176
 
    def setUp(self):
1177
 
        super(TestPatienceDiffLibFiles, self).setUp()
1178
 
        self._PatienceSequenceMatcher = \
1179
 
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1180
 
 
1181
567
    def test_patience_unified_diff_files(self):
1182
568
        txt_a = ['hello there\n',
1183
569
                 'world\n',
1188
574
        open('b1', 'wb').writelines(txt_b)
1189
575
 
1190
576
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1191
 
        psm = self._PatienceSequenceMatcher
1192
 
        self.assertEquals(['--- a1\n',
1193
 
                           '+++ b1\n',
 
577
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
578
        self.assertEquals(['--- a1 \n',
 
579
                           '+++ b1 \n',
1194
580
                           '@@ -1,3 +1,2 @@\n',
1195
581
                           ' hello there\n',
1196
582
                           '-world\n',
1205
591
        open('b2', 'wb').writelines(txt_b)
1206
592
 
1207
593
        # This is the result with LongestCommonSubstring matching
1208
 
        self.assertEquals(['--- a2\n',
1209
 
                           '+++ b2\n',
 
594
        self.assertEquals(['--- a2 \n',
 
595
                           '+++ b2 \n',
1210
596
                           '@@ -1,6 +1,11 @@\n',
1211
597
                           ' a\n',
1212
598
                           ' b\n',
1222
608
                          , list(unified_diff_files('a2', 'b2')))
1223
609
 
1224
610
        # And the patience diff
1225
 
        self.assertEquals(['--- a2\n',
1226
 
                           '+++ b2\n',
 
611
        self.assertEquals(['--- a2 \n',
 
612
                           '+++ b2 \n',
1227
613
                           '@@ -4,6 +4,11 @@\n',
1228
614
                           ' d\n',
1229
615
                           ' e\n',
1239
625
                          ]
1240
626
                          , list(unified_diff_files('a2', 'b2',
1241
627
                                 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)