/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_merge.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-12-21 06:03:07 UTC
  • mfrom: (4665.7.3 serve-init)
  • Revision ID: pqm@pqm.ubuntu.com-20091221060307-uvja3vdy1o6dzzy0
(mbp) example debian init script

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge.py
29
29
    transform,
30
30
    versionedfile,
31
31
    )
32
 
from bzrlib.branch import Branch
33
32
from bzrlib.conflicts import ConflictList, TextConflict
34
 
from bzrlib.errors import UnrelatedBranches, NoCommits, BzrCommandError
 
33
from bzrlib.errors import UnrelatedBranches, NoCommits
35
34
from bzrlib.merge import transform_tree, merge_inner, _PlanMerge
36
35
from bzrlib.osutils import pathjoin, file_kind
37
36
from bzrlib.tests import TestCaseWithTransport, TestCaseWithMemoryTransport
524
523
        self.add_uncommitted_version(('root', 'C:'), [('root', 'A')], 'fabg')
525
524
        return _PlanMerge('B:', 'C:', self.plan_merge_vf, ('root',))
526
525
 
 
526
    def test_base_from_plan(self):
 
527
        self.setup_plan_merge()
 
528
        plan = self.plan_merge_vf.plan_merge('B', 'C')
 
529
        pwm = versionedfile.PlanWeaveMerge(plan)
 
530
        self.assertEqual(['a\n', 'b\n', 'c\n'], pwm.base_from_plan())
 
531
 
527
532
    def test_unique_lines(self):
528
533
        plan = self.setup_plan_merge()
529
534
        self.assertEqual(plan._unique_lines(
827
832
                          ('unchanged', 'f\n'),
828
833
                          ('unchanged', 'g\n')],
829
834
                         list(plan))
 
835
        plan = self.plan_merge_vf.plan_lca_merge('F', 'G')
 
836
        # This is one of the main differences between plan_merge and
 
837
        # plan_lca_merge. plan_lca_merge generates a conflict for 'x => z',
 
838
        # because 'x' was not present in one of the bases. However, in this
 
839
        # case it is spurious because 'x' does not exist in the global base A.
 
840
        self.assertEqual([
 
841
                          ('unchanged', 'h\n'),
 
842
                          ('unchanged', 'a\n'),
 
843
                          ('conflicted-a', 'x\n'),
 
844
                          ('new-b', 'z\n'),
 
845
                          ('unchanged', 'c\n'),
 
846
                          ('unchanged', 'd\n'),
 
847
                          ('unchanged', 'y\n'),
 
848
                          ('unchanged', 'f\n'),
 
849
                          ('unchanged', 'g\n')],
 
850
                         list(plan))
 
851
 
 
852
    def test_criss_cross_flip_flop(self):
 
853
        # This is specificly trying to trigger problems when using limited
 
854
        # ancestry and weaves. The ancestry graph looks like:
 
855
        #       XX      unused ancestor, should not show up in the weave
 
856
        #       |
 
857
        #       A       Unique LCA
 
858
        #      / \  
 
859
        #     B   C     B & C both introduce a new line
 
860
        #     |\ /|  
 
861
        #     | X |  
 
862
        #     |/ \| 
 
863
        #     D   E     B & C are both merged, so both are common ancestors
 
864
        #               In the process of merging, both sides order the new
 
865
        #               lines differently
 
866
        #
 
867
        self.add_rev('root', 'XX', [], 'qrs')
 
868
        self.add_rev('root', 'A', ['XX'], 'abcdef')
 
869
        self.add_rev('root', 'B', ['A'], 'abcdgef')
 
870
        self.add_rev('root', 'C', ['A'], 'abcdhef')
 
871
        self.add_rev('root', 'D', ['B', 'C'], 'abcdghef')
 
872
        self.add_rev('root', 'E', ['C', 'B'], 'abcdhgef')
 
873
        plan = list(self.plan_merge_vf.plan_merge('D', 'E'))
 
874
        self.assertEqual([
 
875
                          ('unchanged', 'a\n'),
 
876
                          ('unchanged', 'b\n'),
 
877
                          ('unchanged', 'c\n'),
 
878
                          ('unchanged', 'd\n'),
 
879
                          ('new-b', 'h\n'),
 
880
                          ('unchanged', 'g\n'),
 
881
                          ('killed-b', 'h\n'),
 
882
                          ('unchanged', 'e\n'),
 
883
                          ('unchanged', 'f\n'),
 
884
                         ], plan)
 
885
        pwm = versionedfile.PlanWeaveMerge(plan)
 
886
        self.assertEqualDiff('\n'.join('abcdghef') + '\n',
 
887
                             ''.join(pwm.base_from_plan()))
 
888
        # Reversing the order reverses the merge plan, and final order of 'hg'
 
889
        # => 'gh'
 
890
        plan = list(self.plan_merge_vf.plan_merge('E', 'D'))
 
891
        self.assertEqual([
 
892
                          ('unchanged', 'a\n'),
 
893
                          ('unchanged', 'b\n'),
 
894
                          ('unchanged', 'c\n'),
 
895
                          ('unchanged', 'd\n'),
 
896
                          ('new-b', 'g\n'),
 
897
                          ('unchanged', 'h\n'),
 
898
                          ('killed-b', 'g\n'),
 
899
                          ('unchanged', 'e\n'),
 
900
                          ('unchanged', 'f\n'),
 
901
                         ], plan)
 
902
        pwm = versionedfile.PlanWeaveMerge(plan)
 
903
        self.assertEqualDiff('\n'.join('abcdhgef') + '\n',
 
904
                             ''.join(pwm.base_from_plan()))
 
905
        # This is where lca differs, in that it (fairly correctly) determines
 
906
        # that there is a conflict because both sides resolved the merge
 
907
        # differently
 
908
        plan = list(self.plan_merge_vf.plan_lca_merge('D', 'E'))
 
909
        self.assertEqual([
 
910
                          ('unchanged', 'a\n'),
 
911
                          ('unchanged', 'b\n'),
 
912
                          ('unchanged', 'c\n'),
 
913
                          ('unchanged', 'd\n'),
 
914
                          ('conflicted-b', 'h\n'),
 
915
                          ('unchanged', 'g\n'),
 
916
                          ('conflicted-a', 'h\n'),
 
917
                          ('unchanged', 'e\n'),
 
918
                          ('unchanged', 'f\n'),
 
919
                         ], plan)
 
920
        pwm = versionedfile.PlanWeaveMerge(plan)
 
921
        self.assertEqualDiff('\n'.join('abcdgef') + '\n',
 
922
                             ''.join(pwm.base_from_plan()))
 
923
        # Reversing it changes what line is doubled, but still gives a
 
924
        # double-conflict
 
925
        plan = list(self.plan_merge_vf.plan_lca_merge('E', 'D'))
 
926
        self.assertEqual([
 
927
                          ('unchanged', 'a\n'),
 
928
                          ('unchanged', 'b\n'),
 
929
                          ('unchanged', 'c\n'),
 
930
                          ('unchanged', 'd\n'),
 
931
                          ('conflicted-b', 'g\n'),
 
932
                          ('unchanged', 'h\n'),
 
933
                          ('conflicted-a', 'g\n'),
 
934
                          ('unchanged', 'e\n'),
 
935
                          ('unchanged', 'f\n'),
 
936
                         ], plan)
 
937
        pwm = versionedfile.PlanWeaveMerge(plan)
 
938
        self.assertEqualDiff('\n'.join('abcdhef') + '\n',
 
939
                             ''.join(pwm.base_from_plan()))
830
940
 
831
941
    def assertRemoveExternalReferences(self, filtered_parent_map,
832
942
                                       child_map, tails, parent_map):
1032
1142
                         ], list(plan))
1033
1143
 
1034
1144
 
1035
 
class TestMergeImplementation(object):
1036
 
 
1037
 
    def do_merge(self, target_tree, source_tree, **kwargs):
1038
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
1039
 
            target_tree, source_tree.last_revision(),
1040
 
            other_branch=source_tree.branch)
1041
 
        merger.merge_type=self.merge_type
1042
 
        for name, value in kwargs.items():
1043
 
            setattr(merger, name, value)
1044
 
        merger.do_merge()
1045
 
 
1046
 
    def test_merge_specific_file(self):
1047
 
        this_tree = self.make_branch_and_tree('this')
1048
 
        this_tree.lock_write()
1049
 
        self.addCleanup(this_tree.unlock)
1050
 
        self.build_tree_contents([
1051
 
            ('this/file1', 'a\nb\n'),
1052
 
            ('this/file2', 'a\nb\n')
1053
 
        ])
1054
 
        this_tree.add(['file1', 'file2'])
1055
 
        this_tree.commit('Added files')
1056
 
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
1057
 
        self.build_tree_contents([
1058
 
            ('other/file1', 'a\nb\nc\n'),
1059
 
            ('other/file2', 'a\nb\nc\n')
1060
 
        ])
1061
 
        other_tree.commit('modified both')
1062
 
        self.build_tree_contents([
1063
 
            ('this/file1', 'd\na\nb\n'),
1064
 
            ('this/file2', 'd\na\nb\n')
1065
 
        ])
1066
 
        this_tree.commit('modified both')
1067
 
        self.do_merge(this_tree, other_tree, interesting_files=['file1'])
1068
 
        self.assertFileEqual('d\na\nb\nc\n', 'this/file1')
1069
 
        self.assertFileEqual('d\na\nb\n', 'this/file2')
1070
 
 
1071
 
    def test_merge_move_and_change(self):
1072
 
        this_tree = self.make_branch_and_tree('this')
1073
 
        this_tree.lock_write()
1074
 
        self.addCleanup(this_tree.unlock)
1075
 
        self.build_tree_contents([
1076
 
            ('this/file1', 'line 1\nline 2\nline 3\nline 4\n'),
1077
 
        ])
1078
 
        this_tree.add('file1',)
1079
 
        this_tree.commit('Added file')
1080
 
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
1081
 
        self.build_tree_contents([
1082
 
            ('other/file1', 'line 1\nline 2 to 2.1\nline 3\nline 4\n'),
1083
 
        ])
1084
 
        other_tree.commit('Changed 2 to 2.1')
1085
 
        self.build_tree_contents([
1086
 
            ('this/file1', 'line 1\nline 3\nline 2\nline 4\n'),
1087
 
        ])
1088
 
        this_tree.commit('Swapped 2 & 3')
1089
 
        self.do_merge(this_tree, other_tree)
1090
 
        self.assertFileEqual('line 1\n'
1091
 
            '<<<<<<< TREE\n'
1092
 
            'line 3\n'
1093
 
            'line 2\n'
1094
 
            '=======\n'
1095
 
            'line 2 to 2.1\n'
1096
 
            'line 3\n'
1097
 
            '>>>>>>> MERGE-SOURCE\n'
1098
 
            'line 4\n', 'this/file1')
1099
 
 
1100
 
    def test_modify_conflicts_with_delete(self):
1101
 
        # If one side deletes a line, and the other modifies that line, then
1102
 
        # the modification should be considered a conflict
1103
 
        builder = self.make_branch_builder('test')
1104
 
        builder.start_series()
1105
 
        builder.build_snapshot('BASE-id', None,
1106
 
            [('add', ('', None, 'directory', None)),
1107
 
             ('add', ('foo', 'foo-id', 'file', 'a\nb\nc\nd\ne\n')),
1108
 
            ])
1109
 
        # Delete 'b\n'
1110
 
        builder.build_snapshot('OTHER-id', ['BASE-id'],
1111
 
            [('modify', ('foo-id', 'a\nc\nd\ne\n'))])
1112
 
        # Modify 'b\n', add 'X\n'
1113
 
        builder.build_snapshot('THIS-id', ['BASE-id'],
1114
 
            [('modify', ('foo-id', 'a\nb2\nc\nd\nX\ne\n'))])
1115
 
        builder.finish_series()
1116
 
        branch = builder.get_branch()
1117
 
        this_tree = branch.bzrdir.create_workingtree()
1118
 
        this_tree.lock_write()
1119
 
        self.addCleanup(this_tree.unlock)
1120
 
        other_tree = this_tree.bzrdir.sprout('other', 'OTHER-id').open_workingtree()
1121
 
        self.do_merge(this_tree, other_tree)
1122
 
        if self.merge_type is _mod_merge.LCAMerger:
1123
 
            self.expectFailure("lca merge doesn't track deleted lines",
1124
 
                self.assertFileEqual,
1125
 
                    'a\n'
1126
 
                    '<<<<<<< TREE\n'
1127
 
                    'b2\n'
1128
 
                    '=======\n'
1129
 
                    '>>>>>>> MERGE-SOURCE\n'
1130
 
                    'c\n'
1131
 
                    'd\n'
1132
 
                    'X\n'
1133
 
                    'e\n', 'test/foo')
1134
 
        else:
1135
 
            self.assertFileEqual(
1136
 
                'a\n'
1137
 
                '<<<<<<< TREE\n'
1138
 
                'b2\n'
1139
 
                '=======\n'
1140
 
                '>>>>>>> MERGE-SOURCE\n'
1141
 
                'c\n'
1142
 
                'd\n'
1143
 
                'X\n'
1144
 
                'e\n', 'test/foo')
1145
 
 
1146
 
 
1147
 
class TestMerge3Merge(TestCaseWithTransport, TestMergeImplementation):
1148
 
 
1149
 
    merge_type = _mod_merge.Merge3Merger
1150
 
 
1151
 
 
1152
 
class TestWeaveMerge(TestCaseWithTransport, TestMergeImplementation):
1153
 
 
1154
 
    merge_type = _mod_merge.WeaveMerger
1155
 
 
1156
 
 
1157
 
class TestLCAMerge(TestCaseWithTransport, TestMergeImplementation):
1158
 
 
1159
 
    merge_type = _mod_merge.LCAMerger
1160
 
 
1161
 
    def test_merge_move_and_change(self):
1162
 
        self.expectFailure("lca merge doesn't conflict for move and change",
1163
 
            super(TestLCAMerge, self).test_merge_move_and_change)
1164
 
 
1165
 
 
1166
1145
class LoggingMerger(object):
1167
1146
    # These seem to be the required attributes
1168
1147
    requires_base = False