/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 breezy/tests/test_merge.py

  • Committer: Jelmer Vernooij
  • Date: 2018-07-07 19:27:38 UTC
  • mto: (7027.4.10 python3-blackbox)
  • mto: This revision was merged to the branch mainline in revision 7038.
  • Revision ID: jelmer@jelmer.uk-20180707192738-cbt5f28lbd3lx4td
Add some more bees; support writing both bytes and unicode strings in build_tree_contents.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_merge.py
566
566
        self.plan_merge_vf.fallback_versionedfiles.append(self.vf)
567
567
 
568
568
    def add_version(self, key, parents, text):
569
 
        self.vf.add_lines(key, parents, [c+'\n' for c in text])
 
569
        self.vf.add_lines(key, parents, [c+b'\n' for c in text])
570
570
 
571
571
    def add_rev(self, prefix, revision_id, parents, text):
572
572
        self.add_version((prefix, revision_id), [(prefix, p) for p in parents],
577
577
                                     [c+'\n' for c in text])
578
578
 
579
579
    def setup_plan_merge(self):
580
 
        self.add_rev('root', 'A', [], 'abc')
581
 
        self.add_rev('root', 'B', ['A'], 'acehg')
582
 
        self.add_rev('root', 'C', ['A'], 'fabg')
 
580
        self.add_rev(b'root', b'A', [], b'abc')
 
581
        self.add_rev(b'root', b'B', [b'A'], b'acehg')
 
582
        self.add_rev(b'root', b'C', [b'A'], b'fabg')
583
583
        return _PlanMerge('B', 'C', self.plan_merge_vf, ('root',))
584
584
 
585
585
    def setup_plan_merge_uncommitted(self):
586
 
        self.add_version(('root', 'A'), [], 'abc')
587
 
        self.add_uncommitted_version(('root', 'B:'), [('root', 'A')], 'acehg')
588
 
        self.add_uncommitted_version(('root', 'C:'), [('root', 'A')], 'fabg')
589
 
        return _PlanMerge('B:', 'C:', self.plan_merge_vf, ('root',))
 
586
        self.add_version((b'root', b'A'), [], b'abc')
 
587
        self.add_uncommitted_version((b'root', b'B:'), [(b'root', b'A')], b'acehg')
 
588
        self.add_uncommitted_version((b'root', b'C:'), [(b'root', b'A')], b'fabg')
 
589
        return _PlanMerge(b'B:', b'C:', self.plan_merge_vf, (b'root',))
590
590
 
591
591
    def test_base_from_plan(self):
592
592
        self.setup_plan_merge()
593
 
        plan = self.plan_merge_vf.plan_merge('B', 'C')
 
593
        plan = self.plan_merge_vf.plan_merge(b'B', b'C')
594
594
        pwm = versionedfile.PlanWeaveMerge(plan)
595
 
        self.assertEqual(['a\n', 'b\n', 'c\n'], pwm.base_from_plan())
 
595
        self.assertEqual([b'a\n', b'b\n', b'c\n'], pwm.base_from_plan())
596
596
 
597
597
    def test_unique_lines(self):
598
598
        plan = self.setup_plan_merge()
599
599
        self.assertEqual(plan._unique_lines(
600
 
            plan._get_matching_blocks('B', 'C')),
 
600
            plan._get_matching_blocks(b'B', b'C')),
601
601
            ([1, 2, 3], [0, 2]))
602
602
 
603
603
    def test_plan_merge(self):
604
604
        self.setup_plan_merge()
605
 
        plan = self.plan_merge_vf.plan_merge('B', 'C')
 
605
        plan = self.plan_merge_vf.plan_merge(b'B', b'C')
606
606
        self.assertEqual([
607
 
                          ('new-b', 'f\n'),
608
 
                          ('unchanged', 'a\n'),
609
 
                          ('killed-a', 'b\n'),
610
 
                          ('killed-b', 'c\n'),
611
 
                          ('new-a', 'e\n'),
612
 
                          ('new-a', 'h\n'),
613
 
                          ('new-a', 'g\n'),
614
 
                          ('new-b', 'g\n')],
 
607
                          ('new-b', b'f\n'),
 
608
                          ('unchanged', b'a\n'),
 
609
                          ('killed-a', b'b\n'),
 
610
                          ('killed-b', b'c\n'),
 
611
                          ('new-a', b'e\n'),
 
612
                          ('new-a', b'h\n'),
 
613
                          ('new-a', b'g\n'),
 
614
                          ('new-b', b'g\n')],
615
615
                         list(plan))
616
616
 
617
617
    def test_plan_merge_cherrypick(self):
618
 
        self.add_rev('root', 'A', [], 'abc')
619
 
        self.add_rev('root', 'B', ['A'], 'abcde')
620
 
        self.add_rev('root', 'C', ['A'], 'abcefg')
621
 
        self.add_rev('root', 'D', ['A', 'B', 'C'], 'abcdegh')
622
 
        my_plan = _PlanMerge('B', 'D', self.plan_merge_vf, ('root',))
 
618
        self.add_rev(b'root', b'A', [], b'abc')
 
619
        self.add_rev(b'root', b'B', [b'A'], b'abcde')
 
620
        self.add_rev(b'root', b'C', [b'A'], b'abcefg')
 
621
        self.add_rev(b'root', b'D', [b'A', b'B', b'C'], b'abcdegh')
 
622
        my_plan = _PlanMerge(b'B', b'D', self.plan_merge_vf, (b'root',))
623
623
        # We shortcut when one text supersedes the other in the per-file graph.
624
624
        # We don't actually need to compare the texts at this point.
625
625
        self.assertEqual([
626
 
                          ('new-b', 'a\n'),
627
 
                          ('new-b', 'b\n'),
628
 
                          ('new-b', 'c\n'),
629
 
                          ('new-b', 'd\n'),
630
 
                          ('new-b', 'e\n'),
631
 
                          ('new-b', 'g\n'),
632
 
                          ('new-b', 'h\n')],
 
626
                          ('new-b', b'a\n'),
 
627
                          ('new-b', b'b\n'),
 
628
                          ('new-b', b'c\n'),
 
629
                          ('new-b', b'd\n'),
 
630
                          ('new-b', b'e\n'),
 
631
                          ('new-b', b'g\n'),
 
632
                          ('new-b', b'h\n')],
633
633
                          list(my_plan.plan_merge()))
634
634
 
635
635
    def test_plan_merge_no_common_ancestor(self):
636
 
        self.add_rev('root', 'A', [], 'abc')
637
 
        self.add_rev('root', 'B', [], 'xyz')
638
 
        my_plan = _PlanMerge('A', 'B', self.plan_merge_vf, ('root',))
 
636
        self.add_rev(b'root', b'A', [], b'abc')
 
637
        self.add_rev(b'root', b'B', [], b'xyz')
 
638
        my_plan = _PlanMerge(b'A', b'B', self.plan_merge_vf, (b'root',))
639
639
        self.assertEqual([
640
 
                          ('new-a', 'a\n'),
641
 
                          ('new-a', 'b\n'),
642
 
                          ('new-a', 'c\n'),
643
 
                          ('new-b', 'x\n'),
644
 
                          ('new-b', 'y\n'),
645
 
                          ('new-b', 'z\n')],
 
640
                          ('new-a', b'a\n'),
 
641
                          ('new-a', b'b\n'),
 
642
                          ('new-a', b'c\n'),
 
643
                          ('new-b', b'x\n'),
 
644
                          ('new-b', b'y\n'),
 
645
                          ('new-b', b'z\n')],
646
646
                          list(my_plan.plan_merge()))
647
647
 
648
648
    def test_plan_merge_tail_ancestors(self):