← 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: John Arbash Meinel
  • Date: 2006-08-15 14:06:37 UTC
  • mto: This revision was merged to the branch mainline in revision 1926.
  • Revision ID: john@arbash-meinel.com-20060815140637-fa80ad04e689d5e4
Fix accidental import removal

Show diffs side-by-side

added added

removed removed

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