← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_merge.py

(jam) Teach bzr merge --weave/--lca how to create a .BASE file (bug
        #40412)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge.py
38
38
from bzrlib.workingtree import WorkingTree
39
39
from bzrlib.transform import TreeTransform
40
40
 
 
41
 
41
42
class TestMerge(TestCaseWithTransport):
42
43
    """Test appending more than one revision"""
43
44
 
524
525
        self.add_uncommitted_version(('root', 'C:'), [('root', 'A')], 'fabg')
525
526
        return _PlanMerge('B:', 'C:', self.plan_merge_vf, ('root',))
526
527
 
 
528
    def test_base_from_plan(self):
 
529
        self.setup_plan_merge()
 
530
        plan = self.plan_merge_vf.plan_merge('B', 'C')
 
531
        pwm = versionedfile.PlanWeaveMerge(plan)
 
532
        self.assertEqual(['a\n', 'b\n', 'c\n'], pwm.base_from_plan())
 
533
 
527
534
    def test_unique_lines(self):
528
535
        plan = self.setup_plan_merge()
529
536
        self.assertEqual(plan._unique_lines(
827
834
                          ('unchanged', 'f\n'),
828
835
                          ('unchanged', 'g\n')],
829
836
                         list(plan))
 
837
        plan = self.plan_merge_vf.plan_lca_merge('F', 'G')
 
838
        # This is one of the main differences between plan_merge and
 
839
        # plan_lca_merge. plan_lca_merge generates a conflict for 'x => z',
 
840
        # because 'x' was not present in one of the bases. However, in this
 
841
        # case it is spurious because 'x' does not exist in the global base A.
 
842
        self.assertEqual([
 
843
                          ('unchanged', 'h\n'),
 
844
                          ('unchanged', 'a\n'),
 
845
                          ('conflicted-a', 'x\n'),
 
846
                          ('new-b', 'z\n'),
 
847
                          ('unchanged', 'c\n'),
 
848
                          ('unchanged', 'd\n'),
 
849
                          ('unchanged', 'y\n'),
 
850
                          ('unchanged', 'f\n'),
 
851
                          ('unchanged', 'g\n')],
 
852
                         list(plan))
 
853
 
 
854
    def test_criss_cross_flip_flop(self):
 
855
        # This is specificly trying to trigger problems when using limited
 
856
        # ancestry and weaves. The ancestry graph looks like:
 
857
        #       XX      unused ancestor, should not show up in the weave
 
858
        #       |
 
859
        #       A       Unique LCA
 
860
        #      / \  
 
861
        #     B   C     B & C both introduce a new line
 
862
        #     |\ /|  
 
863
        #     | X |  
 
864
        #     |/ \| 
 
865
        #     D   E     B & C are both merged, so both are common ancestors
 
866
        #               In the process of merging, both sides order the new
 
867
        #               lines differently
 
868
        #
 
869
        self.add_rev('root', 'XX', [], 'qrs')
 
870
        self.add_rev('root', 'A', ['XX'], 'abcdef')
 
871
        self.add_rev('root', 'B', ['A'], 'abcdgef')
 
872
        self.add_rev('root', 'C', ['A'], 'abcdhef')
 
873
        self.add_rev('root', 'D', ['B', 'C'], 'abcdghef')
 
874
        self.add_rev('root', 'E', ['C', 'B'], 'abcdhgef')
 
875
        plan = list(self.plan_merge_vf.plan_merge('D', 'E'))
 
876
        self.assertEqual([
 
877
                          ('unchanged', 'a\n'),
 
878
                          ('unchanged', 'b\n'),
 
879
                          ('unchanged', 'c\n'),
 
880
                          ('unchanged', 'd\n'),
 
881
                          ('new-b', 'h\n'),
 
882
                          ('unchanged', 'g\n'),
 
883
                          ('killed-b', 'h\n'),
 
884
                          ('unchanged', 'e\n'),
 
885
                          ('unchanged', 'f\n'),
 
886
                         ], plan)
 
887
        pwm = versionedfile.PlanWeaveMerge(plan)
 
888
        self.assertEqualDiff('\n'.join('abcdghef') + '\n',
 
889
                             ''.join(pwm.base_from_plan()))
 
890
        # Reversing the order reverses the merge plan, and final order of 'hg'
 
891
        # => 'gh'
 
892
        plan = list(self.plan_merge_vf.plan_merge('E', 'D'))
 
893
        self.assertEqual([
 
894
                          ('unchanged', 'a\n'),
 
895
                          ('unchanged', 'b\n'),
 
896
                          ('unchanged', 'c\n'),
 
897
                          ('unchanged', 'd\n'),
 
898
                          ('new-b', 'g\n'),
 
899
                          ('unchanged', 'h\n'),
 
900
                          ('killed-b', 'g\n'),
 
901
                          ('unchanged', 'e\n'),
 
902
                          ('unchanged', 'f\n'),
 
903
                         ], plan)
 
904
        pwm = versionedfile.PlanWeaveMerge(plan)
 
905
        self.assertEqualDiff('\n'.join('abcdhgef') + '\n',
 
906
                             ''.join(pwm.base_from_plan()))
 
907
        # This is where lca differs, in that it (fairly correctly) determines
 
908
        # that there is a conflict because both sides resolved the merge
 
909
        # differently
 
910
        plan = list(self.plan_merge_vf.plan_lca_merge('D', 'E'))
 
911
        self.assertEqual([
 
912
                          ('unchanged', 'a\n'),
 
913
                          ('unchanged', 'b\n'),
 
914
                          ('unchanged', 'c\n'),
 
915
                          ('unchanged', 'd\n'),
 
916
                          ('conflicted-b', 'h\n'),
 
917
                          ('unchanged', 'g\n'),
 
918
                          ('conflicted-a', 'h\n'),
 
919
                          ('unchanged', 'e\n'),
 
920
                          ('unchanged', 'f\n'),
 
921
                         ], plan)
 
922
        pwm = versionedfile.PlanWeaveMerge(plan)
 
923
        self.assertEqualDiff('\n'.join('abcdgef') + '\n',
 
924
                             ''.join(pwm.base_from_plan()))
 
925
        # Reversing it changes what line is doubled, but still gives a
 
926
        # double-conflict
 
927
        plan = list(self.plan_merge_vf.plan_lca_merge('E', 'D'))
 
928
        self.assertEqual([
 
929
                          ('unchanged', 'a\n'),
 
930
                          ('unchanged', 'b\n'),
 
931
                          ('unchanged', 'c\n'),
 
932
                          ('unchanged', 'd\n'),
 
933
                          ('conflicted-b', 'g\n'),
 
934
                          ('unchanged', 'h\n'),
 
935
                          ('conflicted-a', 'g\n'),
 
936
                          ('unchanged', 'e\n'),
 
937
                          ('unchanged', 'f\n'),
 
938
                         ], plan)
 
939
        pwm = versionedfile.PlanWeaveMerge(plan)
 
940
        self.assertEqualDiff('\n'.join('abcdhef') + '\n',
 
941
                             ''.join(pwm.base_from_plan()))
830
942
 
831
943
    def assertRemoveExternalReferences(self, filtered_parent_map,
832
944
                                       child_map, tails, parent_map):