435
449
tree.rename_one('file', 'newname')
436
450
self.build_tree_contents([('tree/newname', 'new contents\n')])
437
diff = self.get_diff(tree.basis_tree(), tree)
438
self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
439
self.assertContainsRe(diff, '--- old/file\t')
440
self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
441
self.assertContainsRe(diff, '-contents\n'
445
class TestPatienceDiffLib(TestCase):
451
d = get_diff_as_string(tree.basis_tree(), tree)
452
self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
453
self.assertContainsRe(d, '--- old/file\t')
454
self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
455
self.assertContainsRe(d, '-contents\n'
459
def test_internal_diff_exec_property(self):
460
tree = self.make_branch_and_tree('tree')
462
tt = transform.TreeTransform(tree)
463
tt.new_file('a', tt.root, 'contents\n', 'a-id', True)
464
tt.new_file('b', tt.root, 'contents\n', 'b-id', False)
465
tt.new_file('c', tt.root, 'contents\n', 'c-id', True)
466
tt.new_file('d', tt.root, 'contents\n', 'd-id', False)
467
tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)
468
tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)
470
tree.commit('one', rev_id='rev-1')
472
tt = transform.TreeTransform(tree)
473
tt.set_executability(False, tt.trans_id_file_id('a-id'))
474
tt.set_executability(True, tt.trans_id_file_id('b-id'))
475
tt.set_executability(False, tt.trans_id_file_id('c-id'))
476
tt.set_executability(True, tt.trans_id_file_id('d-id'))
478
tree.rename_one('c', 'new-c')
479
tree.rename_one('d', 'new-d')
481
d = get_diff_as_string(tree.basis_tree(), tree)
483
self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
485
self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
487
self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
489
self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
491
self.assertNotContainsRe(d, r"file 'e'")
492
self.assertNotContainsRe(d, r"file 'f'")
494
def test_binary_unicode_filenames(self):
495
"""Test that contents of files are *not* encoded in UTF-8 when there
496
is a binary file in the diff.
498
# See https://bugs.launchpad.net/bugs/110092.
499
self.requireFeature(features.UnicodeFilenameFeature)
501
# This bug isn't triggered with cStringIO.
502
from StringIO import StringIO
503
tree = self.make_branch_and_tree('tree')
504
alpha, omega = u'\u03b1', u'\u03c9'
505
alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')
506
self.build_tree_contents(
507
[('tree/' + alpha, chr(0)),
509
('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])
510
tree.add([alpha], ['file-id'])
511
tree.add([omega], ['file-id-2'])
512
diff_content = StringIO()
513
diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
514
d = diff_content.getvalue()
515
self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
516
self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
517
% (alpha_utf8, alpha_utf8))
518
self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
519
self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
520
self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
522
def test_unicode_filename(self):
523
"""Test when the filename are unicode."""
524
self.requireFeature(features.UnicodeFilenameFeature)
526
alpha, omega = u'\u03b1', u'\u03c9'
527
autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
529
tree = self.make_branch_and_tree('tree')
530
self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])
531
tree.add(['ren_'+alpha], ['file-id-2'])
532
self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])
533
tree.add(['del_'+alpha], ['file-id-3'])
534
self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])
535
tree.add(['mod_'+alpha], ['file-id-4'])
537
tree.commit('one', rev_id='rev-1')
539
tree.rename_one('ren_'+alpha, 'ren_'+omega)
540
tree.remove('del_'+alpha)
541
self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])
542
tree.add(['add_'+alpha], ['file-id'])
543
self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
545
d = get_diff_as_string(tree.basis_tree(), tree)
546
self.assertContainsRe(d,
547
"=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
548
self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
549
self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
550
self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
552
def test_unicode_filename_path_encoding(self):
553
"""Test for bug #382699: unicode filenames on Windows should be shown
556
self.requireFeature(features.UnicodeFilenameFeature)
557
# The word 'test' in Russian
558
_russian_test = u'\u0422\u0435\u0441\u0442'
559
directory = _russian_test + u'/'
560
test_txt = _russian_test + u'.txt'
561
u1234 = u'\u1234.txt'
563
tree = self.make_branch_and_tree('.')
564
self.build_tree_contents([
569
tree.add([test_txt, u1234, directory])
572
diff.show_diff_trees(tree.basis_tree(), tree, sio,
573
path_encoding='cp1251')
575
output = subst_dates(sio.getvalue())
577
=== added directory '%(directory)s'
578
=== added file '%(test_txt)s'
579
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
580
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
584
=== added file '?.txt'
585
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
586
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
590
''' % {'directory': _russian_test.encode('cp1251'),
591
'test_txt': test_txt.encode('cp1251'),
593
self.assertEqualDiff(output, shouldbe)
596
class DiffWasIs(diff.DiffPath):
598
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
599
self.to_file.write('was: ')
600
self.to_file.write(self.old_tree.get_file(file_id).read())
601
self.to_file.write('is: ')
602
self.to_file.write(self.new_tree.get_file(file_id).read())
606
class TestDiffTree(tests.TestCaseWithTransport):
609
super(TestDiffTree, self).setUp()
610
self.old_tree = self.make_branch_and_tree('old-tree')
611
self.old_tree.lock_write()
612
self.addCleanup(self.old_tree.unlock)
613
self.new_tree = self.make_branch_and_tree('new-tree')
614
self.new_tree.lock_write()
615
self.addCleanup(self.new_tree.unlock)
616
self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
618
def test_diff_text(self):
619
self.build_tree_contents([('old-tree/olddir/',),
620
('old-tree/olddir/oldfile', 'old\n')])
621
self.old_tree.add('olddir')
622
self.old_tree.add('olddir/oldfile', 'file-id')
623
self.build_tree_contents([('new-tree/newdir/',),
624
('new-tree/newdir/newfile', 'new\n')])
625
self.new_tree.add('newdir')
626
self.new_tree.add('newdir/newfile', 'file-id')
627
differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
628
differ.diff_text('file-id', None, 'old label', 'new label')
630
'--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
631
differ.to_file.getvalue())
632
differ.to_file.seek(0)
633
differ.diff_text(None, 'file-id', 'old label', 'new label')
635
'--- old label\n+++ new label\n@@ -0,0 +1,1 @@\n+new\n\n',
636
differ.to_file.getvalue())
637
differ.to_file.seek(0)
638
differ.diff_text('file-id', 'file-id', 'old label', 'new label')
640
'--- old label\n+++ new label\n@@ -1,1 +1,1 @@\n-old\n+new\n\n',
641
differ.to_file.getvalue())
643
def test_diff_deletion(self):
644
self.build_tree_contents([('old-tree/file', 'contents'),
645
('new-tree/file', 'contents')])
646
self.old_tree.add('file', 'file-id')
647
self.new_tree.add('file', 'file-id')
648
os.unlink('new-tree/file')
649
self.differ.show_diff(None)
650
self.assertContainsRe(self.differ.to_file.getvalue(), '-contents')
652
def test_diff_creation(self):
653
self.build_tree_contents([('old-tree/file', 'contents'),
654
('new-tree/file', 'contents')])
655
self.old_tree.add('file', 'file-id')
656
self.new_tree.add('file', 'file-id')
657
os.unlink('old-tree/file')
658
self.differ.show_diff(None)
659
self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
661
def test_diff_symlink(self):
662
differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
663
differ.diff_symlink('old target', None)
664
self.assertEqual("=== target was 'old target'\n",
665
differ.to_file.getvalue())
667
differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
668
differ.diff_symlink(None, 'new target')
669
self.assertEqual("=== target is 'new target'\n",
670
differ.to_file.getvalue())
672
differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
673
differ.diff_symlink('old target', 'new target')
674
self.assertEqual("=== target changed 'old target' => 'new target'\n",
675
differ.to_file.getvalue())
678
self.build_tree_contents([('old-tree/olddir/',),
679
('old-tree/olddir/oldfile', 'old\n')])
680
self.old_tree.add('olddir')
681
self.old_tree.add('olddir/oldfile', 'file-id')
682
self.build_tree_contents([('new-tree/newdir/',),
683
('new-tree/newdir/newfile', 'new\n')])
684
self.new_tree.add('newdir')
685
self.new_tree.add('newdir/newfile', 'file-id')
686
self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
687
self.assertContainsRe(
688
self.differ.to_file.getvalue(),
689
r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
690
' \@\@\n-old\n\+new\n\n')
692
def test_diff_kind_change(self):
693
self.requireFeature(features.SymlinkFeature)
694
self.build_tree_contents([('old-tree/olddir/',),
695
('old-tree/olddir/oldfile', 'old\n')])
696
self.old_tree.add('olddir')
697
self.old_tree.add('olddir/oldfile', 'file-id')
698
self.build_tree(['new-tree/newdir/'])
699
os.symlink('new', 'new-tree/newdir/newfile')
700
self.new_tree.add('newdir')
701
self.new_tree.add('newdir/newfile', 'file-id')
702
self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
703
self.assertContainsRe(
704
self.differ.to_file.getvalue(),
705
r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
707
self.assertContainsRe(self.differ.to_file.getvalue(),
708
"=== target is u'new'\n")
710
def test_diff_directory(self):
711
self.build_tree(['new-tree/new-dir/'])
712
self.new_tree.add('new-dir', 'new-dir-id')
713
self.differ.diff('new-dir-id', None, 'new-dir')
714
self.assertEqual(self.differ.to_file.getvalue(), '')
716
def create_old_new(self):
717
self.build_tree_contents([('old-tree/olddir/',),
718
('old-tree/olddir/oldfile', 'old\n')])
719
self.old_tree.add('olddir')
720
self.old_tree.add('olddir/oldfile', 'file-id')
721
self.build_tree_contents([('new-tree/newdir/',),
722
('new-tree/newdir/newfile', 'new\n')])
723
self.new_tree.add('newdir')
724
self.new_tree.add('newdir/newfile', 'file-id')
726
def test_register_diff(self):
727
self.create_old_new()
728
old_diff_factories = diff.DiffTree.diff_factories
729
diff.DiffTree.diff_factories=old_diff_factories[:]
730
diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
732
differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
734
diff.DiffTree.diff_factories = old_diff_factories
735
differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
736
self.assertNotContainsRe(
737
differ.to_file.getvalue(),
738
r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
739
' \@\@\n-old\n\+new\n\n')
740
self.assertContainsRe(differ.to_file.getvalue(),
741
'was: old\nis: new\n')
743
def test_extra_factories(self):
744
self.create_old_new()
745
differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
746
extra_factories=[DiffWasIs.from_diff_tree])
747
differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
748
self.assertNotContainsRe(
749
differ.to_file.getvalue(),
750
r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
751
' \@\@\n-old\n\+new\n\n')
752
self.assertContainsRe(differ.to_file.getvalue(),
753
'was: old\nis: new\n')
755
def test_alphabetical_order(self):
756
self.build_tree(['new-tree/a-file'])
757
self.new_tree.add('a-file')
758
self.build_tree(['old-tree/b-file'])
759
self.old_tree.add('b-file')
760
self.differ.show_diff(None)
761
self.assertContainsRe(self.differ.to_file.getvalue(),
762
'.*a-file(.|\n)*b-file')
765
class TestPatienceDiffLib(tests.TestCase):
768
super(TestPatienceDiffLib, self).setUp()
769
self._unique_lcs = _patiencediff_py.unique_lcs_py
770
self._recurse_matches = _patiencediff_py.recurse_matches_py
771
self._PatienceSequenceMatcher = \
772
_patiencediff_py.PatienceSequenceMatcher_py
774
def test_diff_unicode_string(self):
775
a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
776
b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
777
sm = self._PatienceSequenceMatcher(None, a, b)
778
mb = sm.get_matching_blocks()
779
self.assertEquals(35, len(mb))
447
781
def test_unique_lcs(self):
448
unique_lcs = bzrlib.patiencediff.unique_lcs
782
unique_lcs = self._unique_lcs
449
783
self.assertEquals(unique_lcs('', ''), [])
784
self.assertEquals(unique_lcs('', 'a'), [])
785
self.assertEquals(unique_lcs('a', ''), [])
450
786
self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
451
787
self.assertEquals(unique_lcs('a', 'b'), [])
452
788
self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
453
789
self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
454
790
self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
455
self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
791
self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
457
793
self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
459
795
def test_recurse_matches(self):
460
796
def test_one(a, b, matches):
461
797
test_matches = []
462
bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
798
self._recurse_matches(
799
a, b, 0, 0, len(a), len(b), test_matches, 10)
464
800
self.assertEquals(test_matches, matches)
466
802
test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
467
803
[(0, 0), (2, 2), (4, 4)])
468
804
test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
469
805
[(0, 0), (2, 1), (4, 2)])
806
# Even though 'bc' is not unique globally, and is surrounded by
807
# non-matching lines, we should still match, because they are locally
809
test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
810
(4, 6), (5, 7), (6, 8)])
471
# recurse_matches doesn't match non-unique
812
# recurse_matches doesn't match non-unique
472
813
# lines surrounded by bogus text.
473
814
# The update has been done in patiencediff.SequenceMatcher instead
478
819
# This is what it currently gives:
479
820
test_one('aBccDe', 'abccde', [(0,0), (5,5)])
822
def assertDiffBlocks(self, a, b, expected_blocks):
823
"""Check that the sequence matcher returns the correct blocks.
825
:param a: A sequence to match
826
:param b: Another sequence to match
827
:param expected_blocks: The expected output, not including the final
828
matching block (len(a), len(b), 0)
830
matcher = self._PatienceSequenceMatcher(None, a, b)
831
blocks = matcher.get_matching_blocks()
833
self.assertEqual((len(a), len(b), 0), last)
834
self.assertEqual(expected_blocks, blocks)
481
836
def test_matching_blocks(self):
482
def chk_blocks(a, b, expected_blocks):
483
# difflib always adds a signature of the total
484
# length, with no matching entries at the end
485
s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
486
blocks = s.get_matching_blocks()
487
self.assertEquals((len(a), len(b), 0), blocks[-1])
488
self.assertEquals(expected_blocks, blocks[:-1])
490
837
# Some basic matching tests
491
chk_blocks('', '', [])
492
chk_blocks([], [], [])
493
chk_blocks('abcd', 'abcd', [(0, 0, 4)])
494
chk_blocks('abcd', 'abce', [(0, 0, 3)])
495
chk_blocks('eabc', 'abce', [(1, 0, 3)])
496
chk_blocks('eabce', 'abce', [(1, 0, 4)])
497
chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
498
chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
499
chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
500
# This may check too much, but it checks to see that
838
self.assertDiffBlocks('', '', [])
839
self.assertDiffBlocks([], [], [])
840
self.assertDiffBlocks('abc', '', [])
841
self.assertDiffBlocks('', 'abc', [])
842
self.assertDiffBlocks('abcd', 'abcd', [(0, 0, 4)])
843
self.assertDiffBlocks('abcd', 'abce', [(0, 0, 3)])
844
self.assertDiffBlocks('eabc', 'abce', [(1, 0, 3)])
845
self.assertDiffBlocks('eabce', 'abce', [(1, 0, 4)])
846
self.assertDiffBlocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
847
self.assertDiffBlocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
848
self.assertDiffBlocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
849
# This may check too much, but it checks to see that
501
850
# a copied block stays attached to the previous section,
502
851
# not the later one.
503
852
# difflib would tend to grab the trailing longest match
504
853
# which would make the diff not look right
505
chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
506
[(0, 0, 6), (6, 11, 10)])
854
self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
855
[(0, 0, 6), (6, 11, 10)])
508
857
# make sure it supports passing in lists
858
self.assertDiffBlocks(
510
859
['hello there\n',
512
861
'how are you today?\n'],
517
866
# non unique lines surrounded by non-matching lines
519
chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
868
self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
521
870
# But they only need to be locally unique
522
chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
871
self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
524
873
# non unique blocks won't be matched
525
chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
874
self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
527
876
# but locally unique ones will
528
chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
877
self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
529
878
(5,4,1), (7,5,2), (10,8,1)])
531
chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
532
chk_blocks('abbabbbb', 'cabbabbc', [])
533
chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
880
self.assertDiffBlocks('abbabbXd', 'cabbabxd', [(7,7,1)])
881
self.assertDiffBlocks('abbabbbb', 'cabbabbc', [])
882
self.assertDiffBlocks('bbbbbbbb', 'cbbbbbbc', [])
884
def test_matching_blocks_tuples(self):
885
# Some basic matching tests
886
self.assertDiffBlocks([], [], [])
887
self.assertDiffBlocks([('a',), ('b',), ('c,')], [], [])
888
self.assertDiffBlocks([], [('a',), ('b',), ('c,')], [])
889
self.assertDiffBlocks([('a',), ('b',), ('c,')],
890
[('a',), ('b',), ('c,')],
892
self.assertDiffBlocks([('a',), ('b',), ('c,')],
893
[('a',), ('b',), ('d,')],
895
self.assertDiffBlocks([('d',), ('b',), ('c,')],
896
[('a',), ('b',), ('c,')],
898
self.assertDiffBlocks([('d',), ('a',), ('b',), ('c,')],
899
[('a',), ('b',), ('c,')],
901
self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
902
[('a', 'b'), ('c', 'X'), ('e', 'f')],
903
[(0, 0, 1), (2, 2, 1)])
904
self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
905
[('a', 'b'), ('c', 'dX'), ('e', 'f')],
906
[(0, 0, 1), (2, 2, 1)])
535
908
def test_opcodes(self):
536
909
def chk_ops(a, b, expected_codes):
537
s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
910
s = self._PatienceSequenceMatcher(None, a, b)
538
911
self.assertEquals(expected_codes, s.get_opcodes())
540
913
chk_ops('', '', [])
541
914
chk_ops([], [], [])
915
chk_ops('abc', '', [('delete', 0,3, 0,0)])
916
chk_ops('', 'abc', [('insert', 0,0, 0,3)])
542
917
chk_ops('abcd', 'abcd', [('equal', 0,4, 0,4)])
543
918
chk_ops('abcd', 'abce', [('equal', 0,3, 0,3),
544
919
('replace', 3,4, 3,4)
606
981
('equal', 10,11, 8,9)
984
def test_grouped_opcodes(self):
985
def chk_ops(a, b, expected_codes, n=3):
986
s = self._PatienceSequenceMatcher(None, a, b)
987
self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
991
chk_ops('abc', '', [[('delete', 0,3, 0,0)]])
992
chk_ops('', 'abc', [[('insert', 0,0, 0,3)]])
993
chk_ops('abcd', 'abcd', [])
994
chk_ops('abcd', 'abce', [[('equal', 0,3, 0,3),
995
('replace', 3,4, 3,4)
997
chk_ops('eabc', 'abce', [[('delete', 0,1, 0,0),
1001
chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
1002
[[('equal', 3,6, 3,6),
1003
('insert', 6,6, 6,11),
1004
('equal', 6,9, 11,14)
1006
chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
1007
[[('equal', 2,6, 2,6),
1008
('insert', 6,6, 6,11),
1009
('equal', 6,10, 11,15)
1011
chk_ops('Xabcdef', 'abcdef',
1012
[[('delete', 0,1, 0,0),
1015
chk_ops('abcdef', 'abcdefX',
1016
[[('equal', 3,6, 3,6),
1017
('insert', 6,6, 6,7)
609
1021
def test_multiple_ranges(self):
610
1022
# There was an earlier bug where we used a bad set of ranges,
611
1023
# this triggers that specific bug, to make sure it doesn't regress
612
def chk_blocks(a, b, expected_blocks):
613
# difflib always adds a signature of the total
614
# length, with no matching entries at the end
615
s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
616
blocks = s.get_matching_blocks()
618
self.assertEquals(x, (len(a), len(b), 0))
619
self.assertEquals(expected_blocks, blocks)
621
chk_blocks('abcdefghijklmnop'
622
, 'abcXghiYZQRSTUVWXYZijklmnop'
623
, [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
625
chk_blocks('ABCd efghIjk L'
626
, 'AxyzBCn mo pqrstuvwI1 2 L'
627
, [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
1024
self.assertDiffBlocks('abcdefghijklmnop',
1025
'abcXghiYZQRSTUVWXYZijklmnop',
1026
[(0, 0, 3), (6, 4, 3), (9, 20, 7)])
1028
self.assertDiffBlocks('ABCd efghIjk L',
1029
'AxyzBCn mo pqrstuvwI1 2 L',
1030
[(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
629
1032
# These are rot13 code snippets.
1033
self.assertDiffBlocks('''\
631
1034
trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
633
1036
gnxrf_netf = ['svyr*']
634
1037
gnxrf_bcgvbaf = ['ab-erphefr']
636
1039
qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
637
1040
sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
792
1247
, list(unified_diff_files('a2', 'b2',
793
1248
sequencematcher=psm)))
1251
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1253
_test_needs_features = [features.compiled_patiencediff_feature]
1256
super(TestPatienceDiffLibFiles_c, self).setUp()
1257
from bzrlib import _patiencediff_c
1258
self._PatienceSequenceMatcher = \
1259
_patiencediff_c.PatienceSequenceMatcher_c
1262
class TestUsingCompiledIfAvailable(tests.TestCase):
1264
def test_PatienceSequenceMatcher(self):
1265
if features.compiled_patiencediff_feature.available():
1266
from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1267
self.assertIs(PatienceSequenceMatcher_c,
1268
patiencediff.PatienceSequenceMatcher)
1270
from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1271
self.assertIs(PatienceSequenceMatcher_py,
1272
patiencediff.PatienceSequenceMatcher)
1274
def test_unique_lcs(self):
1275
if features.compiled_patiencediff_feature.available():
1276
from bzrlib._patiencediff_c import unique_lcs_c
1277
self.assertIs(unique_lcs_c,
1278
patiencediff.unique_lcs)
1280
from bzrlib._patiencediff_py import unique_lcs_py
1281
self.assertIs(unique_lcs_py,
1282
patiencediff.unique_lcs)
1284
def test_recurse_matches(self):
1285
if features.compiled_patiencediff_feature.available():
1286
from bzrlib._patiencediff_c import recurse_matches_c
1287
self.assertIs(recurse_matches_c,
1288
patiencediff.recurse_matches)
1290
from bzrlib._patiencediff_py import recurse_matches_py
1291
self.assertIs(recurse_matches_py,
1292
patiencediff.recurse_matches)
1295
class TestDiffFromTool(tests.TestCaseWithTransport):
1297
def test_from_string(self):
1298
diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
1299
self.addCleanup(diff_obj.finish)
1300
self.assertEqual(['diff', '@old_path', '@new_path'],
1301
diff_obj.command_template)
1303
def test_from_string_u5(self):
1304
diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1306
self.addCleanup(diff_obj.finish)
1307
self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1308
diff_obj.command_template)
1309
self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1310
diff_obj._get_command('old-path', 'new-path'))
1312
def test_from_string_path_with_backslashes(self):
1313
self.requireFeature(features.backslashdir_feature)
1314
tool = 'C:\\Tools\\Diff.exe'
1315
diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1316
self.addCleanup(diff_obj.finish)
1317
self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1318
diff_obj.command_template)
1319
self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1320
diff_obj._get_command('old-path', 'new-path'))
1322
def test_execute(self):
1324
diff_obj = diff.DiffFromTool(['python', '-c',
1325
'print "@old_path @new_path"'],
1327
self.addCleanup(diff_obj.finish)
1328
diff_obj._execute('old', 'new')
1329
self.assertEqual(output.getvalue().rstrip(), 'old new')
1331
def test_excute_missing(self):
1332
diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1334
self.addCleanup(diff_obj.finish)
1335
e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1337
self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1338
' on this machine', str(e))
1340
def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1341
self.requireFeature(features.AttribFeature)
1343
tree = self.make_branch_and_tree('tree')
1344
self.build_tree_contents([('tree/file', 'content')])
1345
tree.add('file', 'file-id')
1346
tree.commit('old tree')
1348
self.addCleanup(tree.unlock)
1349
basis_tree = tree.basis_tree()
1350
basis_tree.lock_read()
1351
self.addCleanup(basis_tree.unlock)
1352
diff_obj = diff.DiffFromTool(['python', '-c',
1353
'print "@old_path @new_path"'],
1354
basis_tree, tree, output)
1355
diff_obj._prepare_files('file-id', 'file', 'file')
1356
# The old content should be readonly
1357
self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1359
# The new content should use the tree object, not a 'new' file anymore
1360
self.assertEndsWith(tree.basedir, 'work/tree')
1361
self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1363
def assertReadableByAttrib(self, cwd, relpath, regex):
1364
proc = subprocess.Popen(['attrib', relpath],
1365
stdout=subprocess.PIPE,
1367
(result, err) = proc.communicate()
1368
self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1370
def test_prepare_files(self):
1372
tree = self.make_branch_and_tree('tree')
1373
self.build_tree_contents([('tree/oldname', 'oldcontent')])
1374
self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1375
tree.add('oldname', 'file-id')
1376
tree.add('oldname2', 'file2-id')
1377
# Earliest allowable date on FAT32 filesystems is 1980-01-01
1378
tree.commit('old tree', timestamp=315532800)
1379
tree.rename_one('oldname', 'newname')
1380
tree.rename_one('oldname2', 'newname2')
1381
self.build_tree_contents([('tree/newname', 'newcontent')])
1382
self.build_tree_contents([('tree/newname2', 'newcontent2')])
1383
old_tree = tree.basis_tree()
1384
old_tree.lock_read()
1385
self.addCleanup(old_tree.unlock)
1387
self.addCleanup(tree.unlock)
1388
diff_obj = diff.DiffFromTool(['python', '-c',
1389
'print "@old_path @new_path"'],
1390
old_tree, tree, output)
1391
self.addCleanup(diff_obj.finish)
1392
self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1393
old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1395
self.assertContainsRe(old_path, 'old/oldname$')
1396
self.assertEqual(315532800, os.stat(old_path).st_mtime)
1397
self.assertContainsRe(new_path, 'tree/newname$')
1398
self.assertFileEqual('oldcontent', old_path)
1399
self.assertFileEqual('newcontent', new_path)
1400
if osutils.host_os_dereferences_symlinks():
1401
self.assertTrue(os.path.samefile('tree/newname', new_path))
1402
# make sure we can create files with the same parent directories
1403
diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1406
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
1408
def test_encodable_filename(self):
1409
# Just checks file path for external diff tool.
1410
# We cannot change CPython's internal encoding used by os.exec*.
1412
diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1414
for _, scenario in EncodingAdapter.encoding_scenarios:
1415
encoding = scenario['encoding']
1416
dirname = scenario['info']['directory']
1417
filename = scenario['info']['filename']
1419
self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1420
relpath = dirname + u'/' + filename
1421
fullpath = diffobj._safe_filename('safe', relpath)
1424
fullpath.encode(encoding).decode(encoding)
1426
self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1428
def test_unencodable_filename(self):
1430
diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1432
for _, scenario in EncodingAdapter.encoding_scenarios:
1433
encoding = scenario['encoding']
1434
dirname = scenario['info']['directory']
1435
filename = scenario['info']['filename']
1437
if encoding == 'iso-8859-1':
1438
encoding = 'iso-8859-2'
1440
encoding = 'iso-8859-1'
1442
self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1443
relpath = dirname + u'/' + filename
1444
fullpath = diffobj._safe_filename('safe', relpath)
1447
fullpath.encode(encoding).decode(encoding)
1449
self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1452
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1454
def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1455
"""Call get_trees_and_branches_to_diff_locked."""
1456
return diff.get_trees_and_branches_to_diff_locked(
1457
path_list, revision_specs, old_url, new_url, self.addCleanup)
1459
def test_basic(self):
1460
tree = self.make_branch_and_tree('tree')
1461
(old_tree, new_tree,
1462
old_branch, new_branch,
1463
specific_files, extra_trees) = self.call_gtabtd(
1464
['tree'], None, None, None)
1466
self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1467
self.assertEqual(_mod_revision.NULL_REVISION,
1468
old_tree.get_revision_id())
1469
self.assertEqual(tree.basedir, new_tree.basedir)
1470
self.assertEqual(tree.branch.base, old_branch.base)
1471
self.assertEqual(tree.branch.base, new_branch.base)
1472
self.assertIs(None, specific_files)
1473
self.assertIs(None, extra_trees)
1475
def test_with_rev_specs(self):
1476
tree = self.make_branch_and_tree('tree')
1477
self.build_tree_contents([('tree/file', 'oldcontent')])
1478
tree.add('file', 'file-id')
1479
tree.commit('old tree', timestamp=0, rev_id="old-id")
1480
self.build_tree_contents([('tree/file', 'newcontent')])
1481
tree.commit('new tree', timestamp=0, rev_id="new-id")
1483
revisions = [revisionspec.RevisionSpec.from_string('1'),
1484
revisionspec.RevisionSpec.from_string('2')]
1485
(old_tree, new_tree,
1486
old_branch, new_branch,
1487
specific_files, extra_trees) = self.call_gtabtd(
1488
['tree'], revisions, None, None)
1490
self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1491
self.assertEqual("old-id", old_tree.get_revision_id())
1492
self.assertIsInstance(new_tree, revisiontree.RevisionTree)
1493
self.assertEqual("new-id", new_tree.get_revision_id())
1494
self.assertEqual(tree.branch.base, old_branch.base)
1495
self.assertEqual(tree.branch.base, new_branch.base)
1496
self.assertIs(None, specific_files)
1497
self.assertEqual(tree.basedir, extra_trees[0].basedir)