← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_conflicts.py

  • Committer: Martin Pool
  • Date: 2011-01-20 23:07:25 UTC
  • mfrom: (5626 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5630.
  • Revision ID: mbp@canonical.com-20110120230725-12l7ltnko5x3fgnz
merge news

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_conflicts.py
22
22
    conflicts,
23
23
    errors,
24
24
    option,
25
 
    osutils,
26
25
    tests,
27
26
    )
28
27
from bzrlib.tests import (
62
61
])
63
62
 
64
63
 
65
 
def vary_by_conflicts():
66
 
    for conflict in example_conflicts:
67
 
        yield (conflict.__class__.__name__, {"conflict": conflict})
68
 
 
69
 
 
70
64
class TestConflicts(tests.TestCaseWithTransport):
71
65
 
 
66
    def test_conflicts(self):
 
67
        """Conflicts are detected properly"""
 
68
        # Use BzrDirFormat6 so we can fake conflicts
 
69
        tree = self.make_branch_and_tree('.', format=bzrdir.BzrDirFormat6())
 
70
        self.build_tree_contents([('hello', 'hello world4'),
 
71
                                  ('hello.THIS', 'hello world2'),
 
72
                                  ('hello.BASE', 'hello world1'),
 
73
                                  ('hello.OTHER', 'hello world3'),
 
74
                                  ('hello.sploo.BASE', 'yellowworld'),
 
75
                                  ('hello.sploo.OTHER', 'yellowworld2'),
 
76
                                  ])
 
77
        tree.lock_read()
 
78
        self.assertLength(6, list(tree.list_files()))
 
79
        tree.unlock()
 
80
        tree_conflicts = tree.conflicts()
 
81
        self.assertLength(2, tree_conflicts)
 
82
        self.assertTrue('hello' in tree_conflicts[0].path)
 
83
        self.assertTrue('hello.sploo' in tree_conflicts[1].path)
 
84
        conflicts.restore('hello')
 
85
        conflicts.restore('hello.sploo')
 
86
        self.assertLength(0, tree.conflicts())
 
87
        self.assertFileEqual('hello world2', 'hello')
 
88
        self.assertFalse(os.path.lexists('hello.sploo'))
 
89
        self.assertRaises(errors.NotConflicted, conflicts.restore, 'hello')
 
90
        self.assertRaises(errors.NotConflicted,
 
91
                          conflicts.restore, 'hello.sploo')
 
92
 
72
93
    def test_resolve_conflict_dir(self):
73
94
        tree = self.make_branch_and_tree('.')
74
95
        self.build_tree_contents([('hello', 'hello world4'),
125
146
        self.assertEqual(conflicts.ConflictList([]), tree.conflicts())
126
147
 
127
148
 
128
 
class TestPerConflict(tests.TestCase):
129
 
 
130
 
    scenarios = scenarios.multiply_scenarios(vary_by_conflicts())
131
 
 
132
 
    def test_stringification(self):
133
 
        text = unicode(self.conflict)
134
 
        self.assertContainsString(text, self.conflict.path)
135
 
        self.assertContainsString(text.lower(), "conflict")
136
 
        self.assertContainsString(repr(self.conflict),
137
 
            self.conflict.__class__.__name__)
 
149
class TestConflictStanzas(tests.TestCase):
138
150
 
139
151
    def test_stanza_roundtrip(self):
140
 
        p = self.conflict
141
 
        o = conflicts.Conflict.factory(**p.as_stanza().as_dict())
142
 
        self.assertEqual(o, p)
143
 
 
144
 
        self.assertIsInstance(o.path, unicode)
145
 
 
146
 
        if o.file_id is not None:
147
 
            self.assertIsInstance(o.file_id, str)
148
 
 
149
 
        conflict_path = getattr(o, 'conflict_path', None)
150
 
        if conflict_path is not None:
151
 
            self.assertIsInstance(conflict_path, unicode)
152
 
 
153
 
        conflict_file_id = getattr(o, 'conflict_file_id', None)
154
 
        if conflict_file_id is not None:
155
 
            self.assertIsInstance(conflict_file_id, str)
 
152
        # write and read our example stanza.
 
153
        stanza_iter = example_conflicts.to_stanzas()
 
154
        processed = conflicts.ConflictList.from_stanzas(stanza_iter)
 
155
        for o, p in zip(processed, example_conflicts):
 
156
            self.assertEqual(o, p)
 
157
 
 
158
            self.assertIsInstance(o.path, unicode)
 
159
 
 
160
            if o.file_id is not None:
 
161
                self.assertIsInstance(o.file_id, str)
 
162
 
 
163
            conflict_path = getattr(o, 'conflict_path', None)
 
164
            if conflict_path is not None:
 
165
                self.assertIsInstance(conflict_path, unicode)
 
166
 
 
167
            conflict_file_id = getattr(o, 'conflict_file_id', None)
 
168
            if conflict_file_id is not None:
 
169
                self.assertIsInstance(conflict_file_id, str)
156
170
 
157
171
    def test_stanzification(self):
158
 
        stanza = self.conflict.as_stanza()
159
 
        if 'file_id' in stanza:
160
 
            # In Stanza form, the file_id has to be unicode.
161
 
            self.assertStartsWith(stanza['file_id'], u'\xeed')
162
 
        self.assertStartsWith(stanza['path'], u'p\xe5th')
163
 
        if 'conflict_path' in stanza:
164
 
            self.assertStartsWith(stanza['conflict_path'], u'p\xe5th')
165
 
        if 'conflict_file_id' in stanza:
166
 
            self.assertStartsWith(stanza['conflict_file_id'], u'\xeed')
167
 
 
168
 
 
169
 
class TestConflictList(tests.TestCase):
170
 
 
171
 
    def test_stanzas_roundtrip(self):
172
 
        stanzas_iter = example_conflicts.to_stanzas()
173
 
        processed = conflicts.ConflictList.from_stanzas(stanzas_iter)
174
 
        self.assertEqual(example_conflicts, processed)
175
 
 
176
 
    def test_stringification(self):
177
 
        for text, o in zip(example_conflicts.to_strings(), example_conflicts):
178
 
            self.assertEqual(text, unicode(o))
 
172
        for stanza in example_conflicts.to_stanzas():
 
173
            if 'file_id' in stanza:
 
174
                # In Stanza form, the file_id has to be unicode.
 
175
                self.assertStartsWith(stanza['file_id'], u'\xeed')
 
176
            self.assertStartsWith(stanza['path'], u'p\xe5th')
 
177
            if 'conflict_path' in stanza:
 
178
                self.assertStartsWith(stanza['conflict_path'], u'p\xe5th')
 
179
            if 'conflict_file_id' in stanza:
 
180
                self.assertStartsWith(stanza['conflict_file_id'], u'\xeed')
179
181
 
180
182
 
181
183
# FIXME: The shell-like tests should be converted to real whitebox tests... or
374
376
 
375
377
    scenarios = mirror_scenarios(
376
378
        [
377
 
            # File modified on both sides
 
379
            # File modified/deleted
378
380
            (dict(_base_actions='create_file',
379
381
                  _path='file', _file_id='file-id'),
380
382
             ('filed_modified_A',
381
383
              dict(actions='modify_file_A', check='file_has_content_A')),
382
384
             ('file_modified_B',
383
385
              dict(actions='modify_file_B', check='file_has_content_B')),),
384
 
            # File modified on both sides in dir
385
 
            (dict(_base_actions='create_file_in_dir',
386
 
                  _path='dir/file', _file_id='file-id'),
387
 
             ('filed_modified_A_in_dir',
388
 
              dict(actions='modify_file_A',
389
 
                   check='file_in_dir_has_content_A')),
390
 
             ('file_modified_B',
391
 
              dict(actions='modify_file_B',
392
 
                   check='file_in_dir_has_content_B')),),
393
386
            ])
394
387
 
395
 
    def do_create_file(self, path='file'):
396
 
        return [('add', (path, 'file-id', 'file', 'trunk content\n'))]
 
388
    def do_create_file(self):
 
389
        return [('add', ('file', 'file-id', 'file', 'trunk content\n'))]
397
390
 
398
391
    def do_modify_file_A(self):
399
392
        return [('modify', ('file-id', 'trunk content\nfeature A\n'))]
401
394
    def do_modify_file_B(self):
402
395
        return [('modify', ('file-id', 'trunk content\nfeature B\n'))]
403
396
 
404
 
    def check_file_has_content_A(self, path='file'):
405
 
        self.assertFileEqual('trunk content\nfeature A\n',
406
 
                             osutils.pathjoin('branch', path))
407
 
 
408
 
    def check_file_has_content_B(self, path='file'):
409
 
        self.assertFileEqual('trunk content\nfeature B\n',
410
 
                             osutils.pathjoin('branch', path))
411
 
 
412
 
    def do_create_file_in_dir(self):
413
 
        return [('add', ('dir', 'dir-id', 'directory', '')),
414
 
            ] + self.do_create_file('dir/file')
415
 
 
416
 
    def check_file_in_dir_has_content_A(self):
417
 
        self.check_file_has_content_A('dir/file')
418
 
 
419
 
    def check_file_in_dir_has_content_B(self):
420
 
        self.check_file_has_content_B('dir/file')
 
397
    def check_file_has_content_A(self):
 
398
        self.assertFileEqual('trunk content\nfeature A\n', 'branch/file')
 
399
 
 
400
    def check_file_has_content_B(self):
 
401
        self.assertFileEqual('trunk content\nfeature B\n', 'branch/file')
421
402
 
422
403
    def _get_resolve_path_arg(self, wt, action):
423
404
        return self._path
446
427
              dict(actions='modify_file', check='file_has_more_content')),
447
428
             ('file_deleted',
448
429
              dict(actions='delete_file', check='file_doesnt_exist')),),
449
 
            # File renamed-modified/deleted
450
 
            (dict(_base_actions='create_file',
451
 
                  _path='new-file', _file_id='file-id'),
452
 
             ('file_renamed_and_modified',
453
 
              dict(actions='modify_and_rename_file',
454
 
                   check='file_renamed_and_more_content')),
455
 
             ('file_deleted',
456
 
              dict(actions='delete_file', check='file_doesnt_exist')),),
457
430
            # File modified/deleted in dir
458
431
            (dict(_base_actions='create_file_in_dir',
459
432
                  _path='dir/file', _file_id='file-id'),
471
444
    def do_modify_file(self):
472
445
        return [('modify', ('file-id', 'trunk content\nmore content\n'))]
473
446
 
474
 
    def do_modify_and_rename_file(self):
475
 
        return [('modify', ('file-id', 'trunk content\nmore content\n')),
476
 
                ('rename', ('file', 'new-file'))]
477
 
 
478
447
    def check_file_has_more_content(self):
479
448
        self.assertFileEqual('trunk content\nmore content\n', 'branch/file')
480
449
 
481
 
    def check_file_renamed_and_more_content(self):
482
 
        self.assertFileEqual('trunk content\nmore content\n', 'branch/new-file')
483
 
 
484
450
    def do_delete_file(self):
485
451
        return [('unversion', 'file-id')]
486
452
 
487
453
    def check_file_doesnt_exist(self):
488
 
        self.assertPathDoesNotExist('branch/file')
 
454
        self.failIfExists('branch/file')
489
455
 
490
456
    def do_create_file_in_dir(self):
491
457
        return [('add', ('dir', 'dir-id', 'directory', '')),
498
464
        self.assertFileEqual('trunk content\nmore content\n', 'branch/dir/file')
499
465
 
500
466
    def check_file_in_dir_doesnt_exist(self):
501
 
        self.assertPathDoesNotExist('branch/dir/file')
 
467
        self.failIfExists('branch/dir/file')
502
468
 
503
469
    def _get_resolve_path_arg(self, wt, action):
504
470
        return self._path
579
545
        return [('rename', ('file', 'new-file'))]
580
546
 
581
547
    def check_file_renamed(self):
582
 
        self.assertPathDoesNotExist('branch/file')
583
 
        self.assertPathExists('branch/new-file')
 
548
        self.failIfExists('branch/file')
 
549
        self.failUnlessExists('branch/new-file')
584
550
 
585
551
    def do_rename_file2(self):
586
552
        return [('rename', ('file', 'new-file2'))]
587
553
 
588
554
    def check_file_renamed2(self):
589
 
        self.assertPathDoesNotExist('branch/file')
590
 
        self.assertPathExists('branch/new-file2')
 
555
        self.failIfExists('branch/file')
 
556
        self.failUnlessExists('branch/new-file2')
591
557
 
592
558
    def do_rename_dir(self):
593
559
        return [('rename', ('dir', 'new-dir'))]
594
560
 
595
561
    def check_dir_renamed(self):
596
 
        self.assertPathDoesNotExist('branch/dir')
597
 
        self.assertPathExists('branch/new-dir')
 
562
        self.failIfExists('branch/dir')
 
563
        self.failUnlessExists('branch/new-dir')
598
564
 
599
565
    def do_rename_dir2(self):
600
566
        return [('rename', ('dir', 'new-dir2'))]
601
567
 
602
568
    def check_dir_renamed2(self):
603
 
        self.assertPathDoesNotExist('branch/dir')
604
 
        self.assertPathExists('branch/new-dir2')
 
569
        self.failIfExists('branch/dir')
 
570
        self.failUnlessExists('branch/new-dir2')
605
571
 
606
572
    def do_delete_file(self):
607
573
        return [('unversion', 'file-id')]
608
574
 
609
575
    def check_file_doesnt_exist(self):
610
 
        self.assertPathDoesNotExist('branch/file')
 
576
        self.failIfExists('branch/file')
611
577
 
612
578
    def do_delete_dir(self):
613
579
        return [('unversion', 'dir-id')]
614
580
 
615
581
    def check_dir_doesnt_exist(self):
616
 
        self.assertPathDoesNotExist('branch/dir')
 
582
        self.failIfExists('branch/dir')
617
583
 
618
584
    def do_create_file_in_dir(self):
619
585
        return [('add', ('dir', 'dir-id', 'directory', '')),
623
589
        return [('rename', ('dir/file', 'dir/new-file'))]
624
590
 
625
591
    def check_file_in_dir_renamed(self):
626
 
        self.assertPathDoesNotExist('branch/dir/file')
627
 
        self.assertPathExists('branch/dir/new-file')
 
592
        self.failIfExists('branch/dir/file')
 
593
        self.failUnlessExists('branch/dir/new-file')
628
594
 
629
595
    def check_file_in_dir_doesnt_exist(self):
630
 
        self.assertPathDoesNotExist('branch/dir/file')
 
596
        self.failIfExists('branch/dir/file')
631
597
 
632
598
    def _get_resolve_path_arg(self, wt, action):
633
599
        tpath = self._this['path']
741
707
        self.run_script("""
742
708
$ bzr rm -q dir  --force
743
709
$ bzr resolve dir
744
 
2>2 conflicts resolved, 0 remaining
 
710
2>2 conflict(s) resolved, 0 remaining
745
711
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
746
712
""")
747
713
 
748
714
    def test_take_other(self):
749
715
        self.run_script("""
750
716
$ bzr resolve dir
751
 
2>2 conflicts resolved, 0 remaining
 
717
2>2 conflict(s) resolved, 0 remaining
752
718
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
753
719
""")
754
720
 
782
748
    def test_keep_them_all(self):
783
749
        self.run_script("""
784
750
$ bzr resolve dir
785
 
2>2 conflicts resolved, 0 remaining
 
751
2>2 conflict(s) resolved, 0 remaining
786
752
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
787
753
""")
788
754
 
791
757
$ bzr mv -q dir/file2 file2
792
758
$ bzr rm -q dir --force
793
759
$ bzr resolve dir
794
 
2>2 conflicts resolved, 0 remaining
 
760
2>2 conflict(s) resolved, 0 remaining
795
761
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
796
762
""")
797
763
 
799
765
        self.run_script("""
800
766
$ bzr rm -q dir --force
801
767
$ bzr resolve dir
802
 
2>2 conflicts resolved, 0 remaining
 
768
2>2 conflict(s) resolved, 0 remaining
803
769
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
804
770
""")
805
771
 
846
812
    def test_keep_them_all(self):
847
813
        self.run_script("""
848
814
$ bzr resolve dir
849
 
2>2 conflicts resolved, 0 remaining
 
815
2>2 conflict(s) resolved, 0 remaining
850
816
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
851
817
""")
852
818
 
855
821
$ bzr mv -q dir/file2 file2
856
822
$ bzr rm -q dir --force
857
823
$ bzr resolve dir
858
 
2>2 conflicts resolved, 0 remaining
 
824
2>2 conflict(s) resolved, 0 remaining
859
825
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
860
826
""")
861
827
 
863
829
        self.run_script("""
864
830
$ bzr rm -q dir --force
865
831
$ bzr resolve dir
866
 
2>2 conflicts resolved, 0 remaining
 
832
2>2 conflict(s) resolved, 0 remaining
867
833
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
868
834
""")
869
835
 
870
836
    def test_resolve_taking_this(self):
871
837
        self.run_script("""
872
838
$ bzr resolve --take-this dir
873
 
2>2 conflicts resolved, 0 remaining
 
839
2>2 conflict(s) resolved, 0 remaining
874
840
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
875
841
""")
876
842
 
879
845
$ bzr resolve --take-other dir
880
846
2>deleted dir/file2
881
847
2>deleted dir
882
 
2>2 conflicts resolved, 0 remaining
 
848
2>2 conflict(s) resolved, 0 remaining
883
849
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
884
850
""")
885
851
 
924
890
        return [('rename', ('dir1', 'dir2/dir1'))]
925
891
 
926
892
    def check_dir1_moved(self):
927
 
        self.assertPathDoesNotExist('branch/dir1')
928
 
        self.assertPathExists('branch/dir2/dir1')
 
893
        self.failIfExists('branch/dir1')
 
894
        self.failUnlessExists('branch/dir2/dir1')
929
895
 
930
896
    def do_move_dir2_into_dir1(self):
931
897
        return [('rename', ('dir2', 'dir1/dir2'))]
932
898
 
933
899
    def check_dir2_moved(self):
934
 
        self.assertPathDoesNotExist('branch/dir2')
935
 
        self.assertPathExists('branch/dir1/dir2')
 
900
        self.failIfExists('branch/dir2')
 
901
        self.failUnlessExists('branch/dir1/dir2')
936
902
 
937
903
    def do_create_dir1_4(self):
938
904
        return [('add', ('dir1', 'dir1-id', 'directory', '')),
944
910
        return [('rename', ('dir1', 'dir3/dir4/dir1'))]
945
911
 
946
912
    def check_dir1_2_moved(self):
947
 
        self.assertPathDoesNotExist('branch/dir1')
948
 
        self.assertPathExists('branch/dir3/dir4/dir1')
949
 
        self.assertPathExists('branch/dir3/dir4/dir1/dir2')
 
913
        self.failIfExists('branch/dir1')
 
914
        self.failUnlessExists('branch/dir3/dir4/dir1')
 
915
        self.failUnlessExists('branch/dir3/dir4/dir1/dir2')
950
916
 
951
917
    def do_move_dir3_into_dir2(self):
952
918
        return [('rename', ('dir3', 'dir1/dir2/dir3'))]
953
919
 
954
920
    def check_dir3_4_moved(self):
955
 
        self.assertPathDoesNotExist('branch/dir3')
956
 
        self.assertPathExists('branch/dir1/dir2/dir3')
957
 
        self.assertPathExists('branch/dir1/dir2/dir3/dir4')
 
921
        self.failIfExists('branch/dir3')
 
922
        self.failUnlessExists('branch/dir1/dir2/dir3')
 
923
        self.failUnlessExists('branch/dir1/dir2/dir3/dir4')
958
924
 
959
925
    def _get_resolve_path_arg(self, wt, action):
960
926
        # ParentLoop says: moving <conflict_path> into <path>. Cancelled move.
971
937
        if self._other['xfail']:
972
938
            # It's a bit hackish to raise from here relying on being called for
973
939
            # both tests but this avoid overriding test_resolve_taking_other
974
 
            self.knownFailure(
 
940
            raise tests.KnownFailure(
975
941
                "ParentLoop doesn't carry enough info to resolve --take-other")
976
942
    _assert_conflict = assertParentLoop
977
943
 
1009
975
# aside ? -- vila 090916
1010
976
$ bzr add -q foo
1011
977
$ bzr resolve foo.new
1012
 
2>1 conflict resolved, 0 remaining
 
978
2>1 conflict(s) resolved, 0 remaining
1013
979
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
1014
980
""")
1015
981
 
1018
984
$ bzr rm -q foo --force
1019
985
$ bzr mv -q foo.new foo
1020
986
$ bzr resolve foo
1021
 
2>1 conflict resolved, 0 remaining
 
987
2>1 conflict(s) resolved, 0 remaining
1022
988
$ bzr commit -q --strict -m 'No more conflicts nor unknown files'
1023
989
""")
1024
990
 
1063
1029
""")
1064
1030
 
1065
1031
 
1066
 
class TestNoFinalPath(script.TestCaseWithTransportAndScript):
1067
 
 
1068
 
    def test_bug_805809(self):
1069
 
        self.run_script("""
1070
 
$ bzr init trunk
1071
 
Created a standalone tree (format: 2a)
1072
 
$ cd trunk
1073
 
$ echo trunk >file
1074
 
$ bzr add
1075
 
adding file
1076
 
$ bzr commit -m 'create file on trunk'
1077
 
2>Committing to: .../trunk/
1078
 
2>added file
1079
 
2>Committed revision 1.
1080
 
# Create a debian branch based on trunk
1081
 
$ cd ..
1082
 
$ bzr branch trunk -r 1 debian
1083
 
2>Branched 1 revision.
1084
 
$ cd debian
1085
 
$ mkdir dir
1086
 
$ bzr add
1087
 
adding dir
1088
 
$ bzr mv file dir
1089
 
file => dir/file
1090
 
$ bzr commit -m 'rename file to dir/file for debian'
1091
 
2>Committing to: .../debian/
1092
 
2>added dir
1093
 
2>renamed file => dir/file
1094
 
2>Committed revision 2.
1095
 
# Create an experimental branch with a new root-id
1096
 
$ cd ..
1097
 
$ bzr init experimental
1098
 
Created a standalone tree (format: 2a)
1099
 
$ cd experimental
1100
 
# Work around merging into empty branch not being supported
1101
 
# (http://pad.lv/308562)
1102
 
$ echo something >not-empty
1103
 
$ bzr add
1104
 
adding not-empty
1105
 
$ bzr commit -m 'Add some content in experimental'
1106
 
2>Committing to: .../experimental/
1107
 
2>added not-empty
1108
 
2>Committed revision 1.
1109
 
# merge debian even without a common ancestor
1110
 
$ bzr merge ../debian -r0..2
1111
 
2>+N  dir/
1112
 
2>+N  dir/file
1113
 
2>All changes applied successfully.
1114
 
$ bzr commit -m 'merging debian into experimental'
1115
 
2>Committing to: .../experimental/
1116
 
2>added dir
1117
 
2>added dir/file
1118
 
2>Committed revision 2.
1119
 
# Create an ubuntu branch with yet another root-id
1120
 
$ cd ..
1121
 
$ bzr init ubuntu
1122
 
Created a standalone tree (format: 2a)
1123
 
$ cd ubuntu
1124
 
# Work around merging into empty branch not being supported
1125
 
# (http://pad.lv/308562)
1126
 
$ echo something >not-empty-ubuntu
1127
 
$ bzr add
1128
 
adding not-empty-ubuntu
1129
 
$ bzr commit -m 'Add some content in experimental'
1130
 
2>Committing to: .../ubuntu/
1131
 
2>added not-empty-ubuntu
1132
 
2>Committed revision 1.
1133
 
# Also merge debian
1134
 
$ bzr merge ../debian -r0..2
1135
 
2>+N  dir/
1136
 
2>+N  dir/file
1137
 
2>All changes applied successfully.
1138
 
$ bzr commit -m 'merging debian'
1139
 
2>Committing to: .../ubuntu/
1140
 
2>added dir
1141
 
2>added dir/file
1142
 
2>Committed revision 2.
1143
 
# Now try to merge experimental
1144
 
$ bzr merge ../experimental
1145
 
2>+N  not-empty
1146
 
2>Path conflict: dir / dir
1147
 
2>1 conflicts encountered.
1148
 
""")
1149
 
 
1150
 
 
1151
1032
class TestResolveActionOption(tests.TestCase):
1152
1033
 
1153
1034
    def setUp(self):