/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

  • Committer: Robert Collins
  • Date: 2008-08-20 02:07:36 UTC
  • mfrom: (3640 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3682.
  • Revision ID: robertc@robertcollins.net-20080820020736-g2xe4921zzxtymle
Merge bzr.dev

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, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import os
 
18
import os.path
18
19
from cStringIO import StringIO
 
20
import errno
 
21
import subprocess
 
22
import sys
 
23
from tempfile import TemporaryFile
19
24
 
20
 
from bzrlib.diff import internal_diff, show_diff_trees
21
 
from bzrlib.errors import BinaryFile
 
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
    )
 
36
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
 
37
import bzrlib.osutils as osutils
 
38
import bzrlib.transform as transform
22
39
import bzrlib.patiencediff
23
 
from bzrlib.tests import TestCase, TestCaseWithTransport, TestCaseInTempDir
24
 
from bzrlib.tests import TestCase, TestCaseInTempDir
 
40
import bzrlib._patiencediff_py
 
41
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
42
                          TestCaseInTempDir, TestSkipped)
 
43
 
 
44
 
 
45
class _AttribFeature(Feature):
 
46
 
 
47
    def _probe(self):
 
48
        if (sys.platform not in ('cygwin', 'win32')):
 
49
            return False
 
50
        try:
 
51
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
 
52
        except OSError, e:
 
53
            return False
 
54
        return (0 == proc.wait())
 
55
 
 
56
    def feature_name(self):
 
57
        return 'attrib Windows command-line tool'
 
58
 
 
59
AttribFeature = _AttribFeature()
 
60
 
 
61
 
 
62
class _CompiledPatienceDiffFeature(Feature):
 
63
 
 
64
    def _probe(self):
 
65
        try:
 
66
            import bzrlib._patiencediff_c
 
67
        except ImportError:
 
68
            return False
 
69
        return True
 
70
 
 
71
    def feature_name(self):
 
72
        return 'bzrlib._patiencediff_c'
 
73
 
 
74
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
25
75
 
26
76
 
27
77
def udiff_lines(old, new, allow_binary=False):
31
81
    return output.readlines()
32
82
 
33
83
 
 
84
def external_udiff_lines(old, new, use_stringio=False):
 
85
    if use_stringio:
 
86
        # StringIO has no fileno, so it tests a different codepath
 
87
        output = StringIO()
 
88
    else:
 
89
        output = TemporaryFile()
 
90
    try:
 
91
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
92
    except NoDiff:
 
93
        raise TestSkipped('external "diff" not present to test')
 
94
    output.seek(0, 0)
 
95
    lines = output.readlines()
 
96
    output.close()
 
97
    return lines
 
98
 
 
99
 
34
100
class TestDiff(TestCase):
35
101
 
36
102
    def test_add_nl(self):
78
144
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
79
145
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
80
146
 
 
147
    def test_external_diff(self):
 
148
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
 
149
        self.check_patch(lines)
 
150
        self.assertEqual('\n', lines[-1])
 
151
 
 
152
    def test_external_diff_no_fileno(self):
 
153
        # Make sure that we can handle not having a fileno, even
 
154
        # if the diff is large
 
155
        lines = external_udiff_lines(['boo\n']*10000,
 
156
                                     ['goo\n']*10000,
 
157
                                     use_stringio=True)
 
158
        self.check_patch(lines)
 
159
 
 
160
    def test_external_diff_binary_lang_c(self):
 
161
        old_env = {}
 
162
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
 
163
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
164
        try:
 
165
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
166
            # Older versions of diffutils say "Binary files", newer
 
167
            # versions just say "Files".
 
168
            self.assertContainsRe(lines[0],
 
169
                                  '(Binary f|F)iles old and new differ\n')
 
170
            self.assertEquals(lines[1:], ['\n'])
 
171
        finally:
 
172
            for lang, old_val in old_env.iteritems():
 
173
                osutils.set_or_unset_env(lang, old_val)
 
174
 
 
175
    def test_no_external_diff(self):
 
176
        """Check that NoDiff is raised when diff is not available"""
 
177
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
178
        orig_path = os.environ['PATH']
 
179
        try:
 
180
            os.environ['PATH'] = ''
 
181
            self.assertRaises(NoDiff, external_diff,
 
182
                              'old', ['boo\n'], 'new', ['goo\n'],
 
183
                              StringIO(), diff_opts=['-u'])
 
184
        finally:
 
185
            os.environ['PATH'] = orig_path
 
186
        
81
187
    def test_internal_diff_default(self):
82
188
        # Default internal diff encoding is utf8
83
189
        output = StringIO()
126
232
                          ]
127
233
                          , lines)
128
234
 
 
235
    def test_internal_diff_no_content(self):
 
236
        output = StringIO()
 
237
        internal_diff(u'old', [], u'new', [], output)
 
238
        self.assertEqual('', output.getvalue())
 
239
 
 
240
    def test_internal_diff_no_changes(self):
 
241
        output = StringIO()
 
242
        internal_diff(u'old', ['text\n', 'contents\n'],
 
243
                      u'new', ['text\n', 'contents\n'],
 
244
                      output)
 
245
        self.assertEqual('', output.getvalue())
 
246
 
129
247
    def test_internal_diff_returns_bytes(self):
130
248
        import StringIO
131
249
        output = StringIO.StringIO()
135
253
            'internal_diff should return bytestrings')
136
254
 
137
255
 
138
 
class TestDiffDates(TestCaseWithTransport):
 
256
class TestDiffFiles(TestCaseInTempDir):
 
257
 
 
258
    def test_external_diff_binary(self):
 
259
        """The output when using external diff should use diff's i18n error"""
 
260
        # Make sure external_diff doesn't fail in the current LANG
 
261
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
262
 
 
263
        cmd = ['diff', '-u', '--binary', 'old', 'new']
 
264
        open('old', 'wb').write('\x00foobar\n')
 
265
        open('new', 'wb').write('foo\x00bar\n')
 
266
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
 
267
                                     stdin=subprocess.PIPE)
 
268
        out, err = pipe.communicate()
 
269
        # Diff returns '2' on Binary files.
 
270
        self.assertEqual(2, pipe.returncode)
 
271
        # We should output whatever diff tells us, plus a trailing newline
 
272
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
 
273
 
 
274
 
 
275
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
276
    """Has a helper for running show_diff_trees"""
 
277
 
 
278
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
279
        output = StringIO()
 
280
        if working_tree is not None:
 
281
            extra_trees = (working_tree,)
 
282
        else:
 
283
            extra_trees = ()
 
284
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
285
                        extra_trees=extra_trees, old_label='old/',
 
286
                        new_label='new/')
 
287
        return output.getvalue()
 
288
 
 
289
 
 
290
class TestDiffDates(TestShowDiffTreesHelper):
139
291
 
140
292
    def setUp(self):
141
293
        super(TestDiffDates, self).setUp()
175
327
        # set the date stamps for files in the working tree to known values
176
328
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
177
329
 
178
 
    def get_diff(self, tree1, tree2):
179
 
        output = StringIO()
180
 
        show_diff_trees(tree1, tree2, output,
181
 
                        old_label='old/', new_label='new/')
182
 
        return output.getvalue()
183
 
 
184
330
    def test_diff_rev_tree_working_tree(self):
185
331
        output = self.get_diff(self.wt.basis_tree(), self.wt)
186
332
        # note that the date for old/file1 is from rev 2 rather than from
245
391
 
246
392
''')
247
393
 
 
394
    def test_show_diff_specified(self):
 
395
        """A working tree filename can be used to identify a file"""
 
396
        self.wt.rename_one('file1', 'file1b')
 
397
        old_tree = self.b.repository.revision_tree('rev-1')
 
398
        new_tree = self.b.repository.revision_tree('rev-4')
 
399
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
400
                            working_tree=self.wt)
 
401
        self.assertContainsRe(out, 'file1\t')
 
402
 
 
403
    def test_recursive_diff(self):
 
404
        """Children of directories are matched"""
 
405
        os.mkdir('dir1')
 
406
        os.mkdir('dir2')
 
407
        self.wt.add(['dir1', 'dir2'])
 
408
        self.wt.rename_one('file1', 'dir1/file1')
 
409
        old_tree = self.b.repository.revision_tree('rev-1')
 
410
        new_tree = self.b.repository.revision_tree('rev-4')
 
411
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
412
                            working_tree=self.wt)
 
413
        self.assertContainsRe(out, 'file1\t')
 
414
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
415
                            working_tree=self.wt)
 
416
        self.assertNotContainsRe(out, 'file1\t')
 
417
 
 
418
 
 
419
 
 
420
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
421
    """Direct tests for show_diff_trees"""
 
422
 
 
423
    def test_modified_file(self):
 
424
        """Test when a file is modified."""
 
425
        tree = self.make_branch_and_tree('tree')
 
426
        self.build_tree_contents([('tree/file', 'contents\n')])
 
427
        tree.add(['file'], ['file-id'])
 
428
        tree.commit('one', rev_id='rev-1')
 
429
 
 
430
        self.build_tree_contents([('tree/file', 'new contents\n')])
 
431
        diff = self.get_diff(tree.basis_tree(), tree)
 
432
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
433
        self.assertContainsRe(diff, '--- old/file\t')
 
434
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
435
        self.assertContainsRe(diff, '-contents\n'
 
436
                                    '\\+new contents\n')
 
437
 
 
438
    def test_modified_file_in_renamed_dir(self):
 
439
        """Test when a file is modified in a renamed directory."""
 
440
        tree = self.make_branch_and_tree('tree')
 
441
        self.build_tree(['tree/dir/'])
 
442
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
443
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
444
        tree.commit('one', rev_id='rev-1')
 
445
 
 
446
        tree.rename_one('dir', 'other')
 
447
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
 
448
        diff = self.get_diff(tree.basis_tree(), tree)
 
449
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
450
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
 
451
        # XXX: This is technically incorrect, because it used to be at another
 
452
        # location. What to do?
 
453
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
454
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
455
        self.assertContainsRe(diff, '-contents\n'
 
456
                                    '\\+new contents\n')
 
457
 
 
458
    def test_renamed_directory(self):
 
459
        """Test when only a directory is only renamed."""
 
460
        tree = self.make_branch_and_tree('tree')
 
461
        self.build_tree(['tree/dir/'])
 
462
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
463
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
464
        tree.commit('one', rev_id='rev-1')
 
465
 
 
466
        tree.rename_one('dir', 'newdir')
 
467
        diff = self.get_diff(tree.basis_tree(), tree)
 
468
        # Renaming a directory should be a single "you renamed this dir" even
 
469
        # when there are files inside.
 
470
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
 
471
 
 
472
    def test_renamed_file(self):
 
473
        """Test when a file is only renamed."""
 
474
        tree = self.make_branch_and_tree('tree')
 
475
        self.build_tree_contents([('tree/file', 'contents\n')])
 
476
        tree.add(['file'], ['file-id'])
 
477
        tree.commit('one', rev_id='rev-1')
 
478
 
 
479
        tree.rename_one('file', 'newname')
 
480
        diff = self.get_diff(tree.basis_tree(), tree)
 
481
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
482
        # We shouldn't have a --- or +++ line, because there is no content
 
483
        # change
 
484
        self.assertNotContainsRe(diff, '---')
 
485
 
 
486
    def test_renamed_and_modified_file(self):
 
487
        """Test when a file is only renamed."""
 
488
        tree = self.make_branch_and_tree('tree')
 
489
        self.build_tree_contents([('tree/file', 'contents\n')])
 
490
        tree.add(['file'], ['file-id'])
 
491
        tree.commit('one', rev_id='rev-1')
 
492
 
 
493
        tree.rename_one('file', 'newname')
 
494
        self.build_tree_contents([('tree/newname', 'new contents\n')])
 
495
        diff = self.get_diff(tree.basis_tree(), tree)
 
496
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
497
        self.assertContainsRe(diff, '--- old/file\t')
 
498
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
499
        self.assertContainsRe(diff, '-contents\n'
 
500
                                    '\\+new contents\n')
 
501
 
 
502
 
 
503
    def test_internal_diff_exec_property(self):
 
504
        tree = self.make_branch_and_tree('tree')
 
505
 
 
506
        tt = transform.TreeTransform(tree)
 
507
        tt.new_file('a', tt.root, 'contents\n', 'a-id', True)
 
508
        tt.new_file('b', tt.root, 'contents\n', 'b-id', False)
 
509
        tt.new_file('c', tt.root, 'contents\n', 'c-id', True)
 
510
        tt.new_file('d', tt.root, 'contents\n', 'd-id', False)
 
511
        tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)
 
512
        tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)
 
513
        tt.apply()
 
514
        tree.commit('one', rev_id='rev-1')
 
515
 
 
516
        tt = transform.TreeTransform(tree)
 
517
        tt.set_executability(False, tt.trans_id_file_id('a-id'))
 
518
        tt.set_executability(True, tt.trans_id_file_id('b-id'))
 
519
        tt.set_executability(False, tt.trans_id_file_id('c-id'))
 
520
        tt.set_executability(True, tt.trans_id_file_id('d-id'))
 
521
        tt.apply()
 
522
        tree.rename_one('c', 'new-c')
 
523
        tree.rename_one('d', 'new-d')
 
524
 
 
525
        diff = self.get_diff(tree.basis_tree(), tree)
 
526
 
 
527
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
528
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
529
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
530
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
531
        self.assertNotContainsRe(diff, r"file 'e'")
 
532
        self.assertNotContainsRe(diff, r"file 'f'")
 
533
 
 
534
 
 
535
    def test_binary_unicode_filenames(self):
 
536
        """Test that contents of files are *not* encoded in UTF-8 when there
 
537
        is a binary file in the diff.
 
538
        """
 
539
        # See https://bugs.launchpad.net/bugs/110092.
 
540
        self.requireFeature(tests.UnicodeFilenameFeature)
 
541
 
 
542
        # This bug isn't triggered with cStringIO.
 
543
        from StringIO import StringIO
 
544
        tree = self.make_branch_and_tree('tree')
 
545
        alpha, omega = u'\u03b1', u'\u03c9'
 
546
        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')
 
547
        self.build_tree_contents(
 
548
            [('tree/' + alpha, chr(0)),
 
549
             ('tree/' + omega,
 
550
              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])
 
551
        tree.add([alpha], ['file-id'])
 
552
        tree.add([omega], ['file-id-2'])
 
553
        diff_content = StringIO()
 
554
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
555
        diff = diff_content.getvalue()
 
556
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
557
        self.assertContainsRe(
 
558
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
559
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
560
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
561
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
 
562
 
 
563
    def test_unicode_filename(self):
 
564
        """Test when the filename are unicode."""
 
565
        self.requireFeature(tests.UnicodeFilenameFeature)
 
566
 
 
567
        alpha, omega = u'\u03b1', u'\u03c9'
 
568
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
 
569
 
 
570
        tree = self.make_branch_and_tree('tree')
 
571
        self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])
 
572
        tree.add(['ren_'+alpha], ['file-id-2'])
 
573
        self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])
 
574
        tree.add(['del_'+alpha], ['file-id-3'])
 
575
        self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])
 
576
        tree.add(['mod_'+alpha], ['file-id-4'])
 
577
 
 
578
        tree.commit('one', rev_id='rev-1')
 
579
 
 
580
        tree.rename_one('ren_'+alpha, 'ren_'+omega)
 
581
        tree.remove('del_'+alpha)
 
582
        self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])
 
583
        tree.add(['add_'+alpha], ['file-id'])
 
584
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
 
585
 
 
586
        diff = self.get_diff(tree.basis_tree(), tree)
 
587
        self.assertContainsRe(diff,
 
588
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
 
589
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
590
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
591
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
592
 
 
593
 
 
594
class DiffWasIs(DiffPath):
 
595
 
 
596
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
597
        self.to_file.write('was: ')
 
598
        self.to_file.write(self.old_tree.get_file(file_id).read())
 
599
        self.to_file.write('is: ')
 
600
        self.to_file.write(self.new_tree.get_file(file_id).read())
 
601
        pass
 
602
 
 
603
 
 
604
class TestDiffTree(TestCaseWithTransport):
 
605
 
 
606
    def setUp(self):
 
607
        TestCaseWithTransport.setUp(self)
 
608
        self.old_tree = self.make_branch_and_tree('old-tree')
 
609
        self.old_tree.lock_write()
 
610
        self.addCleanup(self.old_tree.unlock)
 
611
        self.new_tree = self.make_branch_and_tree('new-tree')
 
612
        self.new_tree.lock_write()
 
613
        self.addCleanup(self.new_tree.unlock)
 
614
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
 
615
 
 
616
    def test_diff_text(self):
 
617
        self.build_tree_contents([('old-tree/olddir/',),
 
618
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
619
        self.old_tree.add('olddir')
 
620
        self.old_tree.add('olddir/oldfile', 'file-id')
 
621
        self.build_tree_contents([('new-tree/newdir/',),
 
622
                                  ('new-tree/newdir/newfile', 'new\n')])
 
623
        self.new_tree.add('newdir')
 
624
        self.new_tree.add('newdir/newfile', 'file-id')
 
625
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
 
626
        differ.diff_text('file-id', None, 'old label', 'new label')
 
627
        self.assertEqual(
 
628
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
 
629
            differ.to_file.getvalue())
 
630
        differ.to_file.seek(0)
 
631
        differ.diff_text(None, 'file-id', 'old label', 'new label')
 
632
        self.assertEqual(
 
633
            '--- old label\n+++ new label\n@@ -0,0 +1,1 @@\n+new\n\n',
 
634
            differ.to_file.getvalue())
 
635
        differ.to_file.seek(0)
 
636
        differ.diff_text('file-id', 'file-id', 'old label', 'new label')
 
637
        self.assertEqual(
 
638
            '--- old label\n+++ new label\n@@ -1,1 +1,1 @@\n-old\n+new\n\n',
 
639
            differ.to_file.getvalue())
 
640
 
 
641
    def test_diff_deletion(self):
 
642
        self.build_tree_contents([('old-tree/file', 'contents'),
 
643
                                  ('new-tree/file', 'contents')])
 
644
        self.old_tree.add('file', 'file-id')
 
645
        self.new_tree.add('file', 'file-id')
 
646
        os.unlink('new-tree/file')
 
647
        self.differ.show_diff(None)
 
648
        self.assertContainsRe(self.differ.to_file.getvalue(), '-contents')
 
649
 
 
650
    def test_diff_creation(self):
 
651
        self.build_tree_contents([('old-tree/file', 'contents'),
 
652
                                  ('new-tree/file', 'contents')])
 
653
        self.old_tree.add('file', 'file-id')
 
654
        self.new_tree.add('file', 'file-id')
 
655
        os.unlink('old-tree/file')
 
656
        self.differ.show_diff(None)
 
657
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
 
658
 
 
659
    def test_diff_symlink(self):
 
660
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
661
        differ.diff_symlink('old target', None)
 
662
        self.assertEqual("=== target was 'old target'\n",
 
663
                         differ.to_file.getvalue())
 
664
 
 
665
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
666
        differ.diff_symlink(None, 'new target')
 
667
        self.assertEqual("=== target is 'new target'\n",
 
668
                         differ.to_file.getvalue())
 
669
 
 
670
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
671
        differ.diff_symlink('old target', 'new target')
 
672
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
 
673
                         differ.to_file.getvalue())
 
674
 
 
675
    def test_diff(self):
 
676
        self.build_tree_contents([('old-tree/olddir/',),
 
677
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
678
        self.old_tree.add('olddir')
 
679
        self.old_tree.add('olddir/oldfile', 'file-id')
 
680
        self.build_tree_contents([('new-tree/newdir/',),
 
681
                                  ('new-tree/newdir/newfile', 'new\n')])
 
682
        self.new_tree.add('newdir')
 
683
        self.new_tree.add('newdir/newfile', 'file-id')
 
684
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
685
        self.assertContainsRe(
 
686
            self.differ.to_file.getvalue(),
 
687
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
688
             ' \@\@\n-old\n\+new\n\n')
 
689
 
 
690
    def test_diff_kind_change(self):
 
691
        self.requireFeature(tests.SymlinkFeature)
 
692
        self.build_tree_contents([('old-tree/olddir/',),
 
693
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
694
        self.old_tree.add('olddir')
 
695
        self.old_tree.add('olddir/oldfile', 'file-id')
 
696
        self.build_tree(['new-tree/newdir/'])
 
697
        os.symlink('new', 'new-tree/newdir/newfile')
 
698
        self.new_tree.add('newdir')
 
699
        self.new_tree.add('newdir/newfile', 'file-id')
 
700
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
701
        self.assertContainsRe(
 
702
            self.differ.to_file.getvalue(),
 
703
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
 
704
             ' \@\@\n-old\n\n')
 
705
        self.assertContainsRe(self.differ.to_file.getvalue(),
 
706
                              "=== target is 'new'\n")
 
707
 
 
708
    def test_diff_directory(self):
 
709
        self.build_tree(['new-tree/new-dir/'])
 
710
        self.new_tree.add('new-dir', 'new-dir-id')
 
711
        self.differ.diff('new-dir-id', None, 'new-dir')
 
712
        self.assertEqual(self.differ.to_file.getvalue(), '')
 
713
 
 
714
    def create_old_new(self):
 
715
        self.build_tree_contents([('old-tree/olddir/',),
 
716
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
717
        self.old_tree.add('olddir')
 
718
        self.old_tree.add('olddir/oldfile', 'file-id')
 
719
        self.build_tree_contents([('new-tree/newdir/',),
 
720
                                  ('new-tree/newdir/newfile', 'new\n')])
 
721
        self.new_tree.add('newdir')
 
722
        self.new_tree.add('newdir/newfile', 'file-id')
 
723
 
 
724
    def test_register_diff(self):
 
725
        self.create_old_new()
 
726
        old_diff_factories = DiffTree.diff_factories
 
727
        DiffTree.diff_factories=old_diff_factories[:]
 
728
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
729
        try:
 
730
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
 
731
        finally:
 
732
            DiffTree.diff_factories = old_diff_factories
 
733
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
734
        self.assertNotContainsRe(
 
735
            differ.to_file.getvalue(),
 
736
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
737
             ' \@\@\n-old\n\+new\n\n')
 
738
        self.assertContainsRe(differ.to_file.getvalue(),
 
739
                              'was: old\nis: new\n')
 
740
 
 
741
    def test_extra_factories(self):
 
742
        self.create_old_new()
 
743
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
744
                            extra_factories=[DiffWasIs.from_diff_tree])
 
745
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
746
        self.assertNotContainsRe(
 
747
            differ.to_file.getvalue(),
 
748
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
749
             ' \@\@\n-old\n\+new\n\n')
 
750
        self.assertContainsRe(differ.to_file.getvalue(),
 
751
                              'was: old\nis: new\n')
 
752
 
 
753
    def test_alphabetical_order(self):
 
754
        self.build_tree(['new-tree/a-file'])
 
755
        self.new_tree.add('a-file')
 
756
        self.build_tree(['old-tree/b-file'])
 
757
        self.old_tree.add('b-file')
 
758
        self.differ.show_diff(None)
 
759
        self.assertContainsRe(self.differ.to_file.getvalue(),
 
760
            '.*a-file(.|\n)*b-file')
 
761
 
248
762
 
249
763
class TestPatienceDiffLib(TestCase):
250
764
 
 
765
    def setUp(self):
 
766
        super(TestPatienceDiffLib, self).setUp()
 
767
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
768
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
 
769
        self._PatienceSequenceMatcher = \
 
770
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
 
771
 
251
772
    def test_unique_lcs(self):
252
 
        unique_lcs = bzrlib.patiencediff.unique_lcs
 
773
        unique_lcs = self._unique_lcs
253
774
        self.assertEquals(unique_lcs('', ''), [])
 
775
        self.assertEquals(unique_lcs('', 'a'), [])
 
776
        self.assertEquals(unique_lcs('a', ''), [])
254
777
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
255
778
        self.assertEquals(unique_lcs('a', 'b'), [])
256
779
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
263
786
    def test_recurse_matches(self):
264
787
        def test_one(a, b, matches):
265
788
            test_matches = []
266
 
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
267
 
                test_matches, 10)
 
789
            self._recurse_matches(
 
790
                a, b, 0, 0, len(a), len(b), test_matches, 10)
268
791
            self.assertEquals(test_matches, matches)
269
792
 
270
793
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
271
794
                 [(0, 0), (2, 2), (4, 4)])
272
795
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
273
796
                 [(0, 0), (2, 1), (4, 2)])
 
797
        # Even though 'bc' is not unique globally, and is surrounded by
 
798
        # non-matching lines, we should still match, because they are locally
 
799
        # unique
 
800
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
 
801
                                          (4, 6), (5, 7), (6, 8)])
274
802
 
275
803
        # recurse_matches doesn't match non-unique 
276
804
        # lines surrounded by bogus text.
282
810
        # This is what it currently gives:
283
811
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
284
812
 
 
813
    def assertDiffBlocks(self, a, b, expected_blocks):
 
814
        """Check that the sequence matcher returns the correct blocks.
 
815
 
 
816
        :param a: A sequence to match
 
817
        :param b: Another sequence to match
 
818
        :param expected_blocks: The expected output, not including the final
 
819
            matching block (len(a), len(b), 0)
 
820
        """
 
821
        matcher = self._PatienceSequenceMatcher(None, a, b)
 
822
        blocks = matcher.get_matching_blocks()
 
823
        last = blocks.pop()
 
824
        self.assertEqual((len(a), len(b), 0), last)
 
825
        self.assertEqual(expected_blocks, blocks)
 
826
 
285
827
    def test_matching_blocks(self):
286
 
        def chk_blocks(a, b, expected_blocks):
287
 
            # difflib always adds a signature of the total
288
 
            # length, with no matching entries at the end
289
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
290
 
            blocks = s.get_matching_blocks()
291
 
            self.assertEquals((len(a), len(b), 0), blocks[-1])
292
 
            self.assertEquals(expected_blocks, blocks[:-1])
293
 
 
294
828
        # Some basic matching tests
295
 
        chk_blocks('', '', [])
296
 
        chk_blocks([], [], [])
297
 
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
298
 
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
299
 
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
300
 
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
301
 
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
302
 
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
303
 
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
304
 
        # This may check too much, but it checks to see that 
 
829
        self.assertDiffBlocks('', '', [])
 
830
        self.assertDiffBlocks([], [], [])
 
831
        self.assertDiffBlocks('abc', '', [])
 
832
        self.assertDiffBlocks('', 'abc', [])
 
833
        self.assertDiffBlocks('abcd', 'abcd', [(0, 0, 4)])
 
834
        self.assertDiffBlocks('abcd', 'abce', [(0, 0, 3)])
 
835
        self.assertDiffBlocks('eabc', 'abce', [(1, 0, 3)])
 
836
        self.assertDiffBlocks('eabce', 'abce', [(1, 0, 4)])
 
837
        self.assertDiffBlocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
 
838
        self.assertDiffBlocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
 
839
        self.assertDiffBlocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
 
840
        # This may check too much, but it checks to see that
305
841
        # a copied block stays attached to the previous section,
306
842
        # not the later one.
307
843
        # difflib would tend to grab the trailing longest match
308
844
        # which would make the diff not look right
309
 
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
310
 
                   [(0, 0, 6), (6, 11, 10)])
 
845
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
846
                              [(0, 0, 6), (6, 11, 10)])
311
847
 
312
848
        # make sure it supports passing in lists
313
 
        chk_blocks(
 
849
        self.assertDiffBlocks(
314
850
                   ['hello there\n',
315
851
                    'world\n',
316
852
                    'how are you today?\n'],
320
856
 
321
857
        # non unique lines surrounded by non-matching lines
322
858
        # won't be found
323
 
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
859
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
324
860
 
325
861
        # But they only need to be locally unique
326
 
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
862
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
327
863
 
328
864
        # non unique blocks won't be matched
329
 
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
865
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
330
866
 
331
867
        # but locally unique ones will
332
 
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
868
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
333
869
                                              (5,4,1), (7,5,2), (10,8,1)])
334
870
 
335
 
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
336
 
        chk_blocks('abbabbbb', 'cabbabbc', [])
337
 
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
 
871
        self.assertDiffBlocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
872
        self.assertDiffBlocks('abbabbbb', 'cabbabbc', [])
 
873
        self.assertDiffBlocks('bbbbbbbb', 'cbbbbbbc', [])
 
874
 
 
875
    def test_matching_blocks_tuples(self):
 
876
        # Some basic matching tests
 
877
        self.assertDiffBlocks([], [], [])
 
878
        self.assertDiffBlocks([('a',), ('b',), ('c,')], [], [])
 
879
        self.assertDiffBlocks([], [('a',), ('b',), ('c,')], [])
 
880
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
 
881
                              [('a',), ('b',), ('c,')],
 
882
                              [(0, 0, 3)])
 
883
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
 
884
                              [('a',), ('b',), ('d,')],
 
885
                              [(0, 0, 2)])
 
886
        self.assertDiffBlocks([('d',), ('b',), ('c,')],
 
887
                              [('a',), ('b',), ('c,')],
 
888
                              [(1, 1, 2)])
 
889
        self.assertDiffBlocks([('d',), ('a',), ('b',), ('c,')],
 
890
                              [('a',), ('b',), ('c,')],
 
891
                              [(1, 0, 3)])
 
892
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
 
893
                              [('a', 'b'), ('c', 'X'), ('e', 'f')],
 
894
                              [(0, 0, 1), (2, 2, 1)])
 
895
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
 
896
                              [('a', 'b'), ('c', 'dX'), ('e', 'f')],
 
897
                              [(0, 0, 1), (2, 2, 1)])
338
898
 
339
899
    def test_opcodes(self):
340
900
        def chk_ops(a, b, expected_codes):
341
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
901
            s = self._PatienceSequenceMatcher(None, a, b)
342
902
            self.assertEquals(expected_codes, s.get_opcodes())
343
903
 
344
904
        chk_ops('', '', [])
345
905
        chk_ops([], [], [])
 
906
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
 
907
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
346
908
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
347
909
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
348
910
                                 ('replace', 3,4, 3,4)
410
972
                 ('equal',   10,11, 8,9)
411
973
                ])
412
974
 
 
975
    def test_grouped_opcodes(self):
 
976
        def chk_ops(a, b, expected_codes, n=3):
 
977
            s = self._PatienceSequenceMatcher(None, a, b)
 
978
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
 
979
 
 
980
        chk_ops('', '', [])
 
981
        chk_ops([], [], [])
 
982
        chk_ops('abc', '', [[('delete', 0,3, 0,0)]])
 
983
        chk_ops('', 'abc', [[('insert', 0,0, 0,3)]])
 
984
        chk_ops('abcd', 'abcd', [])
 
985
        chk_ops('abcd', 'abce', [[('equal',   0,3, 0,3),
 
986
                                  ('replace', 3,4, 3,4)
 
987
                                 ]])
 
988
        chk_ops('eabc', 'abce', [[('delete', 0,1, 0,0),
 
989
                                 ('equal',  1,4, 0,3),
 
990
                                 ('insert', 4,4, 3,4)
 
991
                                ]])
 
992
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
993
                [[('equal',  3,6, 3,6),
 
994
                  ('insert', 6,6, 6,11),
 
995
                  ('equal',  6,9, 11,14)
 
996
                  ]])
 
997
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
998
                [[('equal',  2,6, 2,6),
 
999
                  ('insert', 6,6, 6,11),
 
1000
                  ('equal',  6,10, 11,15)
 
1001
                  ]], 4)
 
1002
        chk_ops('Xabcdef', 'abcdef',
 
1003
                [[('delete', 0,1, 0,0),
 
1004
                  ('equal',  1,4, 0,3)
 
1005
                  ]])
 
1006
        chk_ops('abcdef', 'abcdefX',
 
1007
                [[('equal',  3,6, 3,6),
 
1008
                  ('insert', 6,6, 6,7)
 
1009
                  ]])
 
1010
 
 
1011
 
413
1012
    def test_multiple_ranges(self):
414
1013
        # There was an earlier bug where we used a bad set of ranges,
415
1014
        # this triggers that specific bug, to make sure it doesn't regress
416
 
        def chk_blocks(a, b, expected_blocks):
417
 
            # difflib always adds a signature of the total
418
 
            # length, with no matching entries at the end
419
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
420
 
            blocks = s.get_matching_blocks()
421
 
            x = blocks.pop()
422
 
            self.assertEquals(x, (len(a), len(b), 0))
423
 
            self.assertEquals(expected_blocks, blocks)
424
 
 
425
 
        chk_blocks('abcdefghijklmnop'
426
 
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
427
 
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
428
 
 
429
 
        chk_blocks('ABCd efghIjk  L'
430
 
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
431
 
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
 
1015
        self.assertDiffBlocks('abcdefghijklmnop',
 
1016
                              'abcXghiYZQRSTUVWXYZijklmnop',
 
1017
                              [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
 
1018
 
 
1019
        self.assertDiffBlocks('ABCd efghIjk  L',
 
1020
                              'AxyzBCn mo pqrstuvwI1 2  L',
 
1021
                              [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
432
1022
 
433
1023
        # These are rot13 code snippets.
434
 
        chk_blocks('''\
 
1024
        self.assertDiffBlocks('''\
435
1025
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
436
1026
    """
437
1027
    gnxrf_netf = ['svyr*']
484
1074
        txt_b = ['hello there\n',
485
1075
                 'how are you today?\n']
486
1076
        unified_diff = bzrlib.patiencediff.unified_diff
487
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
1077
        psm = self._PatienceSequenceMatcher
488
1078
        self.assertEquals([ '---  \n',
489
1079
                           '+++  \n',
490
1080
                           '@@ -1,3 +1,2 @@\n',
532
1122
                                 sequencematcher=psm)))
533
1123
 
534
1124
 
 
1125
class TestPatienceDiffLib_c(TestPatienceDiffLib):
 
1126
 
 
1127
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1128
 
 
1129
    def setUp(self):
 
1130
        super(TestPatienceDiffLib_c, self).setUp()
 
1131
        import bzrlib._patiencediff_c
 
1132
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1133
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
 
1134
        self._PatienceSequenceMatcher = \
 
1135
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1136
 
 
1137
    def test_unhashable(self):
 
1138
        """We should get a proper exception here."""
 
1139
        # We need to be able to hash items in the sequence, lists are
 
1140
        # unhashable, and thus cannot be diffed
 
1141
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1142
                                         None, [[]], [])
 
1143
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1144
                                         None, ['valid', []], [])
 
1145
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1146
                                         None, ['valid'], [[]])
 
1147
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1148
                                         None, ['valid'], ['valid', []])
 
1149
 
 
1150
 
535
1151
class TestPatienceDiffLibFiles(TestCaseInTempDir):
536
1152
 
 
1153
    def setUp(self):
 
1154
        super(TestPatienceDiffLibFiles, self).setUp()
 
1155
        self._PatienceSequenceMatcher = \
 
1156
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
 
1157
 
537
1158
    def test_patience_unified_diff_files(self):
538
1159
        txt_a = ['hello there\n',
539
1160
                 'world\n',
544
1165
        open('b1', 'wb').writelines(txt_b)
545
1166
 
546
1167
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
547
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
1168
        psm = self._PatienceSequenceMatcher
548
1169
        self.assertEquals(['--- a1 \n',
549
1170
                           '+++ b1 \n',
550
1171
                           '@@ -1,3 +1,2 @@\n',
595
1216
                          ]
596
1217
                          , list(unified_diff_files('a2', 'b2',
597
1218
                                 sequencematcher=psm)))
 
1219
 
 
1220
 
 
1221
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
 
1222
 
 
1223
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1224
 
 
1225
    def setUp(self):
 
1226
        super(TestPatienceDiffLibFiles_c, self).setUp()
 
1227
        import bzrlib._patiencediff_c
 
1228
        self._PatienceSequenceMatcher = \
 
1229
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1230
 
 
1231
 
 
1232
class TestUsingCompiledIfAvailable(TestCase):
 
1233
 
 
1234
    def test_PatienceSequenceMatcher(self):
 
1235
        if CompiledPatienceDiffFeature.available():
 
1236
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
 
1237
            self.assertIs(PatienceSequenceMatcher_c,
 
1238
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
1239
        else:
 
1240
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
 
1241
            self.assertIs(PatienceSequenceMatcher_py,
 
1242
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
1243
 
 
1244
    def test_unique_lcs(self):
 
1245
        if CompiledPatienceDiffFeature.available():
 
1246
            from bzrlib._patiencediff_c import unique_lcs_c
 
1247
            self.assertIs(unique_lcs_c,
 
1248
                          bzrlib.patiencediff.unique_lcs)
 
1249
        else:
 
1250
            from bzrlib._patiencediff_py import unique_lcs_py
 
1251
            self.assertIs(unique_lcs_py,
 
1252
                          bzrlib.patiencediff.unique_lcs)
 
1253
 
 
1254
    def test_recurse_matches(self):
 
1255
        if CompiledPatienceDiffFeature.available():
 
1256
            from bzrlib._patiencediff_c import recurse_matches_c
 
1257
            self.assertIs(recurse_matches_c,
 
1258
                          bzrlib.patiencediff.recurse_matches)
 
1259
        else:
 
1260
            from bzrlib._patiencediff_py import recurse_matches_py
 
1261
            self.assertIs(recurse_matches_py,
 
1262
                          bzrlib.patiencediff.recurse_matches)
 
1263
 
 
1264
 
 
1265
class TestDiffFromTool(TestCaseWithTransport):
 
1266
 
 
1267
    def test_from_string(self):
 
1268
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
 
1269
        self.addCleanup(diff_obj.finish)
 
1270
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
 
1271
            diff_obj.command_template)
 
1272
 
 
1273
    def test_from_string_u5(self):
 
1274
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
 
1275
        self.addCleanup(diff_obj.finish)
 
1276
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
 
1277
                         diff_obj.command_template)
 
1278
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
 
1279
                         diff_obj._get_command('old-path', 'new-path'))
 
1280
 
 
1281
    def test_execute(self):
 
1282
        output = StringIO()
 
1283
        diff_obj = DiffFromTool(['python', '-c',
 
1284
                                 'print "%(old_path)s %(new_path)s"'],
 
1285
                                None, None, output)
 
1286
        self.addCleanup(diff_obj.finish)
 
1287
        diff_obj._execute('old', 'new')
 
1288
        self.assertEqual(output.getvalue().rstrip(), 'old new')
 
1289
 
 
1290
    def test_excute_missing(self):
 
1291
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1292
                                None, None, None)
 
1293
        self.addCleanup(diff_obj.finish)
 
1294
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1295
                              'new')
 
1296
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
 
1297
                         ' on this machine', str(e))
 
1298
 
 
1299
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
 
1300
        self.requireFeature(AttribFeature)
 
1301
        output = StringIO()
 
1302
        tree = self.make_branch_and_tree('tree')
 
1303
        self.build_tree_contents([('tree/file', 'content')])
 
1304
        tree.add('file', 'file-id')
 
1305
        tree.commit('old tree')
 
1306
        tree.lock_read()
 
1307
        self.addCleanup(tree.unlock)
 
1308
        diff_obj = DiffFromTool(['python', '-c',
 
1309
                                 'print "%(old_path)s %(new_path)s"'],
 
1310
                                tree, tree, output)
 
1311
        diff_obj._prepare_files('file-id', 'file', 'file')
 
1312
        self.assertReadableByAttrib(diff_obj._root, 'old\\file', r'old\\file')
 
1313
        self.assertReadableByAttrib(diff_obj._root, 'new\\file', r'new\\file')
 
1314
 
 
1315
    def assertReadableByAttrib(self, cwd, relpath, regex):
 
1316
        proc = subprocess.Popen(['attrib', relpath],
 
1317
                                stdout=subprocess.PIPE,
 
1318
                                cwd=cwd)
 
1319
        proc.wait()
 
1320
        result = proc.stdout.read()
 
1321
        self.assertContainsRe(result, regex)
 
1322
 
 
1323
    def test_prepare_files(self):
 
1324
        output = StringIO()
 
1325
        tree = self.make_branch_and_tree('tree')
 
1326
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
 
1327
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
 
1328
        tree.add('oldname', 'file-id')
 
1329
        tree.add('oldname2', 'file2-id')
 
1330
        tree.commit('old tree', timestamp=0)
 
1331
        tree.rename_one('oldname', 'newname')
 
1332
        tree.rename_one('oldname2', 'newname2')
 
1333
        self.build_tree_contents([('tree/newname', 'newcontent')])
 
1334
        self.build_tree_contents([('tree/newname2', 'newcontent2')])
 
1335
        old_tree = tree.basis_tree()
 
1336
        old_tree.lock_read()
 
1337
        self.addCleanup(old_tree.unlock)
 
1338
        tree.lock_read()
 
1339
        self.addCleanup(tree.unlock)
 
1340
        diff_obj = DiffFromTool(['python', '-c',
 
1341
                                 'print "%(old_path)s %(new_path)s"'],
 
1342
                                old_tree, tree, output)
 
1343
        self.addCleanup(diff_obj.finish)
 
1344
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
 
1345
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
 
1346
                                                     'newname')
 
1347
        self.assertContainsRe(old_path, 'old/oldname$')
 
1348
        self.assertEqual(0, os.stat(old_path).st_mtime)
 
1349
        self.assertContainsRe(new_path, 'new/newname$')
 
1350
        self.assertFileEqual('oldcontent', old_path)
 
1351
        self.assertFileEqual('newcontent', new_path)
 
1352
        if osutils.host_os_dereferences_symlinks():
 
1353
            self.assertTrue(os.path.samefile('tree/newname', new_path))
 
1354
        # make sure we can create files with the same parent directories
 
1355
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')