/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: Robert Collins
  • Date: 2008-02-13 03:30:01 UTC
  • mfrom: (3221 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3224.
  • Revision ID: robertc@robertcollins.net-20080213033001-rw70ul0zb02ph856
Merge to fix conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge.py
20
20
from bzrlib import (
21
21
    conflicts,
22
22
    errors,
 
23
    knit,
23
24
    merge as _mod_merge,
24
25
    option,
25
26
    progress,
 
27
    transform,
 
28
    versionedfile,
26
29
    )
27
30
from bzrlib.branch import Branch
28
31
from bzrlib.conflicts import ConflictList, TextConflict
29
32
from bzrlib.errors import UnrelatedBranches, NoCommits, BzrCommandError
30
 
from bzrlib.merge import transform_tree, merge_inner
 
33
from bzrlib.merge import transform_tree, merge_inner, _PlanMerge
31
34
from bzrlib.osutils import pathjoin, file_kind
32
35
from bzrlib.revision import common_ancestor
33
 
from bzrlib.tests import TestCaseWithTransport
 
36
from bzrlib.tests import TestCaseWithTransport, TestCaseWithMemoryTransport
34
37
from bzrlib.trace import (enable_test_log, disable_test_log)
35
38
from bzrlib.workingtree import WorkingTree
36
39
 
136
139
        tree_a.commit(message="hello")
137
140
        dir_b = tree_a.bzrdir.sprout('b')
138
141
        tree_b = dir_b.open_workingtree()
 
142
        tree_b.lock_write()
 
143
        self.addCleanup(tree_b.unlock)
139
144
        tree_a.commit(message="hello again")
140
145
        log = StringIO()
141
146
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(), 
285
290
        merger.merge_type = _mod_merge.Merge3Merger
286
291
        merger.do_merge()
287
292
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
 
293
 
 
294
    def test_merge_uncommitted_otherbasis_ancestor_of_thisbasis_weave(self):
 
295
        tree_a = self.make_branch_and_tree('a')
 
296
        self.build_tree(['a/file_1', 'a/file_2'])
 
297
        tree_a.add(['file_1'])
 
298
        tree_a.commit('commit 1')
 
299
        tree_a.add(['file_2'])
 
300
        tree_a.commit('commit 2')
 
301
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
 
302
        tree_b.rename_one('file_1', 'renamed')
 
303
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
 
304
                                                    progress.DummyProgress())
 
305
        merger.merge_type = _mod_merge.WeaveMerger
 
306
        merger.do_merge()
 
307
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
 
308
 
 
309
    def prepare_cherrypick(self):
 
310
        """Prepare a pair of trees for cherrypicking tests.
 
311
 
 
312
        Both trees have a file, 'file'.
 
313
        rev1 sets content to 'a'.
 
314
        rev2b adds 'b'.
 
315
        rev3b adds 'c'.
 
316
        A full merge of rev2b and rev3b into this_tree would add both 'b' and
 
317
        'c'.  A successful cherrypick of rev2b-rev3b into this_tree will add
 
318
        'c', but not 'b'.
 
319
        """
 
320
        this_tree = self.make_branch_and_tree('this')
 
321
        self.build_tree_contents([('this/file', "a\n")])
 
322
        this_tree.add('file')
 
323
        this_tree.commit('rev1')
 
324
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
325
        self.build_tree_contents([('other/file', "a\nb\n")])
 
326
        other_tree.commit('rev2b', rev_id='rev2b')
 
327
        self.build_tree_contents([('other/file', "c\na\nb\n")])
 
328
        other_tree.commit('rev3b', rev_id='rev3b')
 
329
        this_tree.lock_write()
 
330
        self.addCleanup(this_tree.unlock)
 
331
        return this_tree, other_tree
 
332
 
 
333
    def test_weave_cherrypick(self):
 
334
        this_tree, other_tree = self.prepare_cherrypick()
 
335
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
336
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
 
337
        merger.merge_type = _mod_merge.WeaveMerger
 
338
        merger.do_merge()
 
339
        self.assertFileEqual('c\na\n', 'this/file')
 
340
 
 
341
    def test_weave_cannot_reverse_cherrypick(self):
 
342
        this_tree, other_tree = self.prepare_cherrypick()
 
343
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
344
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
 
345
        merger.merge_type = _mod_merge.WeaveMerger
 
346
        self.assertRaises(errors.CannotReverseCherrypick, merger.do_merge)
 
347
 
 
348
    def test_merge3_can_reverse_cherrypick(self):
 
349
        this_tree, other_tree = self.prepare_cherrypick()
 
350
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
351
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
 
352
        merger.merge_type = _mod_merge.Merge3Merger
 
353
        merger.do_merge()
 
354
 
 
355
    def test_make_merger(self):
 
356
        this_tree = self.make_branch_and_tree('this')
 
357
        this_tree.commit('rev1', rev_id='rev1')
 
358
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
359
        this_tree.commit('rev2', rev_id='rev2a')
 
360
        other_tree.commit('rev2', rev_id='rev2b')
 
361
        this_tree.lock_write()
 
362
        self.addCleanup(this_tree.unlock)
 
363
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress,
 
364
            this_tree, 'rev2b', other_branch=other_tree.branch)
 
365
        merger.merge_type = _mod_merge.Merge3Merger
 
366
        tree_merger = merger.make_merger()
 
367
        self.assertIs(_mod_merge.Merge3Merger, tree_merger.__class__)
 
368
        self.assertEqual('rev2b', tree_merger.other_tree.get_revision_id())
 
369
        self.assertEqual('rev1', tree_merger.base_tree.get_revision_id())
 
370
 
 
371
    def test_make_preview_transform(self):
 
372
        this_tree = self.make_branch_and_tree('this')
 
373
        self.build_tree_contents([('this/file', '1\n')])
 
374
        this_tree.add('file', 'file-id')
 
375
        this_tree.commit('rev1', rev_id='rev1')
 
376
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
377
        self.build_tree_contents([('this/file', '1\n2a\n')])
 
378
        this_tree.commit('rev2', rev_id='rev2a')
 
379
        self.build_tree_contents([('other/file', '2b\n1\n')])
 
380
        other_tree.commit('rev2', rev_id='rev2b')
 
381
        this_tree.lock_write()
 
382
        self.addCleanup(this_tree.unlock)
 
383
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
384
            this_tree, 'rev2b', other_branch=other_tree.branch)
 
385
        merger.merge_type = _mod_merge.Merge3Merger
 
386
        tree_merger = merger.make_merger()
 
387
        tt = tree_merger.make_preview_transform()
 
388
        self.addCleanup(tt.finalize)
 
389
        preview_tree = tt.get_preview_tree()
 
390
        tree_file = this_tree.get_file('file-id')
 
391
        try:
 
392
            self.assertEqual('1\n2a\n', tree_file.read())
 
393
        finally:
 
394
            tree_file.close()
 
395
        preview_file = preview_tree.get_file('file-id')
 
396
        try:
 
397
            self.assertEqual('2b\n1\n2a\n', preview_file.read())
 
398
        finally:
 
399
            preview_file.close()
 
400
 
 
401
    def test_do_merge(self):
 
402
        this_tree = self.make_branch_and_tree('this')
 
403
        self.build_tree_contents([('this/file', '1\n')])
 
404
        this_tree.add('file', 'file-id')
 
405
        this_tree.commit('rev1', rev_id='rev1')
 
406
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
407
        self.build_tree_contents([('this/file', '1\n2a\n')])
 
408
        this_tree.commit('rev2', rev_id='rev2a')
 
409
        self.build_tree_contents([('other/file', '2b\n1\n')])
 
410
        other_tree.commit('rev2', rev_id='rev2b')
 
411
        this_tree.lock_write()
 
412
        self.addCleanup(this_tree.unlock)
 
413
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
414
            this_tree, 'rev2b', other_branch=other_tree.branch)
 
415
        merger.merge_type = _mod_merge.Merge3Merger
 
416
        tree_merger = merger.make_merger()
 
417
        tt = tree_merger.do_merge()
 
418
        tree_file = this_tree.get_file('file-id')
 
419
        try:
 
420
            self.assertEqual('2b\n1\n2a\n', tree_file.read())
 
421
        finally:
 
422
            tree_file.close()
 
423
 
 
424
 
 
425
class TestPlanMerge(TestCaseWithMemoryTransport):
 
426
 
 
427
    def setUp(self):
 
428
        TestCaseWithMemoryTransport.setUp(self)
 
429
        self.vf = knit.KnitVersionedFile('root', self.get_transport(),
 
430
                                         create=True)
 
431
        self.plan_merge_vf = versionedfile._PlanMergeVersionedFile('root',
 
432
                                                                   [self.vf])
 
433
 
 
434
    def add_version(self, version_id, parents, text):
 
435
        self.vf.add_lines(version_id, parents, [c+'\n' for c in text])
 
436
 
 
437
    def add_uncommitted_version(self, version_id, parents, text):
 
438
        self.plan_merge_vf.add_lines(version_id, parents,
 
439
                                     [c+'\n' for c in text])
 
440
 
 
441
    def setup_plan_merge(self):
 
442
        self.add_version('A', [], 'abc')
 
443
        self.add_version('B', ['A'], 'acehg')
 
444
        self.add_version('C', ['A'], 'fabg')
 
445
        return _PlanMerge('B', 'C', self.plan_merge_vf)
 
446
 
 
447
    def setup_plan_merge_uncommitted(self):
 
448
        self.add_version('A', [], 'abc')
 
449
        self.add_uncommitted_version('B:', ['A'], 'acehg')
 
450
        self.add_uncommitted_version('C:', ['A'], 'fabg')
 
451
        return _PlanMerge('B:', 'C:', self.plan_merge_vf)
 
452
 
 
453
    def test_unique_lines(self):
 
454
        plan = self.setup_plan_merge()
 
455
        self.assertEqual(plan._unique_lines(
 
456
            plan._get_matching_blocks('B', 'C')),
 
457
            ([1, 2, 3], [0, 2]))
 
458
 
 
459
    def test_find_new(self):
 
460
        plan = self.setup_plan_merge()
 
461
        self.assertEqual(set([2, 3, 4]), plan._find_new('B'))
 
462
        self.assertEqual(set([0, 3]), plan._find_new('C'))
 
463
 
 
464
    def test_find_new2(self):
 
465
        self.add_version('A', [], 'abc')
 
466
        self.add_version('B', ['A'], 'abcde')
 
467
        self.add_version('C', ['A'], 'abcefg')
 
468
        self.add_version('D', ['A', 'B', 'C'], 'abcdegh')
 
469
        my_plan = _PlanMerge('B', 'D', self.plan_merge_vf)
 
470
        self.assertEqual(set([5, 6]), my_plan._find_new('D'))
 
471
        self.assertEqual(set(), my_plan._find_new('A'))
 
472
 
 
473
    def test_find_new_no_ancestors(self):
 
474
        self.add_version('A', [], 'abc')
 
475
        self.add_version('B', [], 'xyz')
 
476
        my_plan = _PlanMerge('A', 'B', self.vf)
 
477
        self.assertEqual(set([0, 1, 2]), my_plan._find_new('A'))
 
478
 
 
479
    def test_plan_merge(self):
 
480
        self.setup_plan_merge()
 
481
        plan = self.plan_merge_vf.plan_merge('B', 'C')
 
482
        self.assertEqual([
 
483
                          ('new-b', 'f\n'),
 
484
                          ('unchanged', 'a\n'),
 
485
                          ('killed-b', 'c\n'),
 
486
                          ('new-a', 'e\n'),
 
487
                          ('new-a', 'h\n'),
 
488
                          ('killed-a', 'b\n'),
 
489
                          ('unchanged', 'g\n')],
 
490
                         list(plan))
 
491
 
 
492
    def test_plan_merge_uncommitted_files(self):
 
493
        self.setup_plan_merge_uncommitted()
 
494
        plan = self.plan_merge_vf.plan_merge('B:', 'C:')
 
495
        self.assertEqual([
 
496
                          ('new-b', 'f\n'),
 
497
                          ('unchanged', 'a\n'),
 
498
                          ('killed-b', 'c\n'),
 
499
                          ('new-a', 'e\n'),
 
500
                          ('new-a', 'h\n'),
 
501
                          ('killed-a', 'b\n'),
 
502
                          ('unchanged', 'g\n')],
 
503
                         list(plan))
 
504
 
 
505
    def test_subtract_plans(self):
 
506
        old_plan = [
 
507
        ('unchanged', 'a\n'),
 
508
        ('new-a', 'b\n'),
 
509
        ('killed-a', 'c\n'),
 
510
        ('new-b', 'd\n'),
 
511
        ('new-b', 'e\n'),
 
512
        ('killed-b', 'f\n'),
 
513
        ('killed-b', 'g\n'),
 
514
        ]
 
515
        new_plan = [
 
516
        ('unchanged', 'a\n'),
 
517
        ('new-a', 'b\n'),
 
518
        ('killed-a', 'c\n'),
 
519
        ('new-b', 'd\n'),
 
520
        ('new-b', 'h\n'),
 
521
        ('killed-b', 'f\n'),
 
522
        ('killed-b', 'i\n'),
 
523
        ]
 
524
        subtracted_plan = [
 
525
        ('unchanged', 'a\n'),
 
526
        ('new-a', 'b\n'),
 
527
        ('killed-a', 'c\n'),
 
528
        ('new-b', 'h\n'),
 
529
        ('unchanged', 'f\n'),
 
530
        ('killed-b', 'i\n'),
 
531
        ]
 
532
        self.assertEqual(subtracted_plan,
 
533
            list(_PlanMerge._subtract_plans(old_plan, new_plan)))
 
534
 
 
535
    def setup_merge_with_base(self):
 
536
        self.add_version('COMMON', [], 'abc')
 
537
        self.add_version('THIS', ['COMMON'], 'abcd')
 
538
        self.add_version('BASE', ['COMMON'], 'eabc')
 
539
        self.add_version('OTHER', ['BASE'], 'eafb')
 
540
 
 
541
    def test_plan_merge_with_base(self):
 
542
        self.setup_merge_with_base()
 
543
        plan = self.plan_merge_vf.plan_merge('THIS', 'OTHER', 'BASE')
 
544
        self.assertEqual([('unchanged', 'a\n'),
 
545
                          ('new-b', 'f\n'),
 
546
                          ('unchanged', 'b\n'),
 
547
                          ('killed-b', 'c\n'),
 
548
                          ('new-a', 'd\n')
 
549
                         ], list(plan))
 
550
 
 
551
    def test_plan_lca_merge(self):
 
552
        self.setup_plan_merge()
 
553
        plan = self.plan_merge_vf.plan_lca_merge('B', 'C')
 
554
        self.assertEqual([
 
555
                          ('new-b', 'f\n'),
 
556
                          ('unchanged', 'a\n'),
 
557
                          ('killed-b', 'c\n'),
 
558
                          ('new-a', 'e\n'),
 
559
                          ('new-a', 'h\n'),
 
560
                          ('killed-a', 'b\n'),
 
561
                          ('unchanged', 'g\n')],
 
562
                         list(plan))
 
563
 
 
564
    def test_plan_lca_merge_uncommitted_files(self):
 
565
        self.setup_plan_merge_uncommitted()
 
566
        plan = self.plan_merge_vf.plan_lca_merge('B:', 'C:')
 
567
        self.assertEqual([
 
568
                          ('new-b', 'f\n'),
 
569
                          ('unchanged', 'a\n'),
 
570
                          ('killed-b', 'c\n'),
 
571
                          ('new-a', 'e\n'),
 
572
                          ('new-a', 'h\n'),
 
573
                          ('killed-a', 'b\n'),
 
574
                          ('unchanged', 'g\n')],
 
575
                         list(plan))
 
576
 
 
577
    def test_plan_lca_merge_with_base(self):
 
578
        self.setup_merge_with_base()
 
579
        plan = self.plan_merge_vf.plan_lca_merge('THIS', 'OTHER', 'BASE')
 
580
        self.assertEqual([('unchanged', 'a\n'),
 
581
                          ('new-b', 'f\n'),
 
582
                          ('unchanged', 'b\n'),
 
583
                          ('killed-b', 'c\n'),
 
584
                          ('new-a', 'd\n')
 
585
                         ], list(plan))
 
586
 
 
587
    def test_plan_lca_merge_with_criss_cross(self):
 
588
        self.add_version('ROOT', [], 'abc')
 
589
        # each side makes a change
 
590
        self.add_version('REV1', ['ROOT'], 'abcd')
 
591
        self.add_version('REV2', ['ROOT'], 'abce')
 
592
        # both sides merge, discarding others' changes
 
593
        self.add_version('LCA1', ['REV1', 'REV2'], 'abcd')
 
594
        self.add_version('LCA2', ['REV1', 'REV2'], 'abce')
 
595
        plan = self.plan_merge_vf.plan_lca_merge('LCA1', 'LCA2')
 
596
        self.assertEqual([('unchanged', 'a\n'),
 
597
                          ('unchanged', 'b\n'),
 
598
                          ('unchanged', 'c\n'),
 
599
                          ('conflicted-a', 'd\n'),
 
600
                          ('conflicted-b', 'e\n'),
 
601
                         ], list(plan))