~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testmerge3.py

  • Committer: Martin Pool
  • Date: 2005-07-11 03:42:53 UTC
  • Revision ID: mbp@sourcefrog.net-20050711034253-412281abeb9f56ad
doc

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
from bzrlib.selftest import TestCaseInTempDir, TestCase
 
18
from bzrlib.selftest import InTempDir, TestBase
19
19
from bzrlib.merge3 import Merge3
20
20
 
21
 
def split_lines(t):
22
 
    from cStringIO import StringIO
23
 
    return StringIO(t).readlines()
24
 
 
25
 
############################################################
26
 
# test case data from the gnu diffutils manual
27
 
# common base
28
 
TZU = split_lines("""     The Nameless is the origin of Heaven and Earth;
29
 
     The named is the mother of all things.
30
 
     
31
 
     Therefore let there always be non-being,
32
 
       so we may see their subtlety,
33
 
     And let there always be being,
34
 
       so we may see their outcome.
35
 
     The two are the same,
36
 
     But after they are produced,
37
 
       they have different names.
38
 
     They both may be called deep and profound.
39
 
     Deeper and more profound,
40
 
     The door of all subtleties!
41
 
""")
42
 
 
43
 
LAO = split_lines("""     The Way that can be told of is not the eternal Way;
44
 
     The name that can be named is not the eternal name.
45
 
     The Nameless is the origin of Heaven and Earth;
46
 
     The Named is the mother of all things.
47
 
     Therefore let there always be non-being,
48
 
       so we may see their subtlety,
49
 
     And let there always be being,
50
 
       so we may see their outcome.
51
 
     The two are the same,
52
 
     But after they are produced,
53
 
       they have different names.
54
 
""")
55
 
 
56
 
 
57
 
TAO = split_lines("""     The Way that can be told of is not the eternal Way;
58
 
     The name that can be named is not the eternal name.
59
 
     The Nameless is the origin of Heaven and Earth;
60
 
     The named is the mother of all things.
61
 
     
62
 
     Therefore let there always be non-being,
63
 
       so we may see their subtlety,
64
 
     And let there always be being,
65
 
       so we may see their result.
66
 
     The two are the same,
67
 
     But after they are produced,
68
 
       they have different names.
69
 
     
70
 
       -- The Way of Lao-Tzu, tr. Wing-tsit Chan
71
 
 
72
 
""")
73
 
 
74
 
MERGED_RESULT = split_lines("""     The Way that can be told of is not the eternal Way;
75
 
     The name that can be named is not the eternal name.
76
 
     The Nameless is the origin of Heaven and Earth;
77
 
     The Named is the mother of all things.
78
 
     Therefore let there always be non-being,
79
 
       so we may see their subtlety,
80
 
     And let there always be being,
81
 
       so we may see their result.
82
 
     The two are the same,
83
 
     But after they are produced,
84
 
       they have different names.
85
 
<<<<<<< LAO
86
 
=======
87
 
     
88
 
       -- The Way of Lao-Tzu, tr. Wing-tsit Chan
89
 
 
90
 
>>>>>>> TAO
91
 
""")
92
 
 
93
 
class TestMerge3(TestCase):
94
 
 
95
 
    def test_no_changes(self):
96
 
        """No conflicts because nothing changed"""
 
21
 
 
22
 
 
23
 
 
24
 
 
25
class NoChanges(TestBase):
 
26
    """No conflicts because nothing changed"""
 
27
    def runTest(self):
97
28
        m3 = Merge3(['aaa', 'bbb'],
98
29
                    ['aaa', 'bbb'],
99
30
                    ['aaa', 'bbb'])
113
44
        self.assertEquals(list(m3.merge_groups()),
114
45
                          [('unchanged', ['aaa', 'bbb'])])
115
46
 
116
 
    def test_front_insert(self):
 
47
 
 
48
class FrontInsert(TestBase):
 
49
    def runTest(self):
117
50
        m3 = Merge3(['zz'],
118
51
                    ['aaa', 'bbb', 'zz'],
119
52
                    ['zz'])
132
65
                          [('a', ['aaa', 'bbb']),
133
66
                           ('unchanged', ['zz'])])
134
67
        
135
 
    def test_null_insert(self):
 
68
    
 
69
 
 
70
class NullInsert(TestBase):
 
71
    def runTest(self):
136
72
        m3 = Merge3([],
137
73
                    ['aaa', 'bbb'],
138
74
                    [])
 
75
 
139
76
        # todo: should use a sentinal at end as from get_matching_blocks
140
77
        # to match without zz
141
78
        self.assertEquals(list(m3.find_sync_regions()),
146
83
 
147
84
        self.assertEquals(list(m3.merge_lines()),
148
85
                          ['aaa', 'bbb'])
 
86
        
 
87
    
149
88
 
150
 
    def test_no_conflicts(self):
151
 
        """No conflicts because only one side changed"""
 
89
class NoConflicts(TestBase):
 
90
    """No conflicts because only one side changed"""
 
91
    def runTest(self):
152
92
        m3 = Merge3(['aaa', 'bbb'],
153
93
                    ['aaa', '111', 'bbb'],
154
94
                    ['aaa', 'bbb'])
166
106
                           ('a', 1, 2),
167
107
                           ('unchanged', 1, 2),])
168
108
 
169
 
    def test_append_a(self):
 
109
 
 
110
 
 
111
class AppendA(TestBase):
 
112
    def runTest(self):
170
113
        m3 = Merge3(['aaa\n', 'bbb\n'],
171
114
                    ['aaa\n', 'bbb\n', '222\n'],
172
115
                    ['aaa\n', 'bbb\n'])
174
117
        self.assertEquals(''.join(m3.merge_lines()),
175
118
                          'aaa\nbbb\n222\n')
176
119
 
177
 
    def test_append_b(self):
 
120
class AppendB(TestBase):
 
121
    def runTest(self):
178
122
        m3 = Merge3(['aaa\n', 'bbb\n'],
179
123
                    ['aaa\n', 'bbb\n'],
180
124
                    ['aaa\n', 'bbb\n', '222\n'])
182
126
        self.assertEquals(''.join(m3.merge_lines()),
183
127
                          'aaa\nbbb\n222\n')
184
128
 
185
 
    def test_append_agreement(self):
 
129
class AppendAgreement(TestBase):
 
130
    def runTest(self):
186
131
        m3 = Merge3(['aaa\n', 'bbb\n'],
187
132
                    ['aaa\n', 'bbb\n', '222\n'],
188
133
                    ['aaa\n', 'bbb\n', '222\n'])
190
135
        self.assertEquals(''.join(m3.merge_lines()),
191
136
                          'aaa\nbbb\n222\n')
192
137
 
193
 
    def test_append_clash(self):
 
138
class AppendClash(TestBase):
 
139
    def runTest(self):
194
140
        m3 = Merge3(['aaa\n', 'bbb\n'],
195
141
                    ['aaa\n', 'bbb\n', '222\n'],
196
142
                    ['aaa\n', 'bbb\n', '333\n'])
211
157
>> b
212
158
''')
213
159
 
214
 
    def test_insert_agreement(self):
 
160
 
 
161
class InsertAgreement(TestBase):
 
162
    def runTest(self):
215
163
        m3 = Merge3(['aaa\n', 'bbb\n'],
216
164
                    ['aaa\n', '222\n', 'bbb\n'],
217
165
                    ['aaa\n', '222\n', 'bbb\n'])
221
169
                            start_marker='<<',
222
170
                            mid_marker='--',
223
171
                            end_marker='>>')
224
 
        self.assertEquals(''.join(ml), 'aaa\n222\nbbb\n')
225
 
        
226
 
 
227
 
    def test_insert_clash(self):
228
 
        """Both try to insert lines in the same place."""
 
172
        self.assertEquals(''.join(m3.merge_lines()),
 
173
                          'aaa\n222\nbbb\n')
 
174
 
 
175
 
 
176
 
 
177
 
 
178
class InsertClash(TestBase):
 
179
    """Both try to insert lines in the same place."""
 
180
    def runTest(self):
229
181
        m3 = Merge3(['aaa\n', 'bbb\n'],
230
182
                    ['aaa\n', '111\n', 'bbb\n'],
231
183
                    ['aaa\n', '222\n', 'bbb\n'])
264
216
bbb
265
217
''')
266
218
 
267
 
    def test_replace_clash(self):
268
 
        """Both try to insert lines in the same place."""
 
219
 
 
220
 
 
221
class ReplaceClash(TestBase):
 
222
    """Both try to insert lines in the same place."""
 
223
    def runTest(self):
269
224
        m3 = Merge3(['aaa', '000', 'bbb'],
270
225
                    ['aaa', '111', 'bbb'],
271
226
                    ['aaa', '222', 'bbb'])
278
233
                           (2,3, 2,3, 2,3),
279
234
                           (3,3, 3,3, 3,3),])
280
235
 
281
 
    def test_replace_multi(self):
282
 
        """Replacement with regions of different size."""
 
236
 
 
237
 
 
238
class ReplaceMulti(TestBase):
 
239
    """Replacement with regions of different size."""
 
240
    def runTest(self):
283
241
        m3 = Merge3(['aaa', '000', '000', 'bbb'],
284
242
                    ['aaa', '111', '111', '111', 'bbb'],
285
243
                    ['aaa', '222', '222', '222', '222', 'bbb'])
293
251
                           (3,4, 4,5, 5,6),
294
252
                           (4,4, 5,5, 6,6),])
295
253
 
296
 
    def test_merge_poem(self):
297
 
        """Test case from diff3 manual"""
 
254
        
 
255
        
 
256
 
 
257
 
 
258
 
 
259
 
 
260
def split_lines(t):
 
261
    from cStringIO import StringIO
 
262
    return StringIO(t).readlines()
 
263
 
 
264
 
 
265
 
 
266
############################################################
 
267
# test case from the gnu diffutils manual
 
268
 
 
269
# common base
 
270
TZU = split_lines("""     The Nameless is the origin of Heaven and Earth;
 
271
     The named is the mother of all things.
 
272
     
 
273
     Therefore let there always be non-being,
 
274
       so we may see their subtlety,
 
275
     And let there always be being,
 
276
       so we may see their outcome.
 
277
     The two are the same,
 
278
     But after they are produced,
 
279
       they have different names.
 
280
     They both may be called deep and profound.
 
281
     Deeper and more profound,
 
282
     The door of all subtleties!
 
283
""")
 
284
 
 
285
LAO = split_lines("""     The Way that can be told of is not the eternal Way;
 
286
     The name that can be named is not the eternal name.
 
287
     The Nameless is the origin of Heaven and Earth;
 
288
     The Named is the mother of all things.
 
289
     Therefore let there always be non-being,
 
290
       so we may see their subtlety,
 
291
     And let there always be being,
 
292
       so we may see their outcome.
 
293
     The two are the same,
 
294
     But after they are produced,
 
295
       they have different names.
 
296
""")
 
297
 
 
298
 
 
299
TAO = split_lines("""     The Way that can be told of is not the eternal Way;
 
300
     The name that can be named is not the eternal name.
 
301
     The Nameless is the origin of Heaven and Earth;
 
302
     The named is the mother of all things.
 
303
     
 
304
     Therefore let there always be non-being,
 
305
       so we may see their subtlety,
 
306
     And let there always be being,
 
307
       so we may see their result.
 
308
     The two are the same,
 
309
     But after they are produced,
 
310
       they have different names.
 
311
     
 
312
       -- The Way of Lao-Tzu, tr. Wing-tsit Chan
 
313
 
 
314
""")
 
315
 
 
316
MERGED_RESULT = split_lines("""     The Way that can be told of is not the eternal Way;
 
317
     The name that can be named is not the eternal name.
 
318
     The Nameless is the origin of Heaven and Earth;
 
319
     The Named is the mother of all things.
 
320
     Therefore let there always be non-being,
 
321
       so we may see their subtlety,
 
322
     And let there always be being,
 
323
       so we may see their result.
 
324
     The two are the same,
 
325
     But after they are produced,
 
326
       they have different names.
 
327
<<<<<<<< LAO
 
328
========
 
329
     
 
330
       -- The Way of Lao-Tzu, tr. Wing-tsit Chan
 
331
 
 
332
>>>>>>>> TAO
 
333
""")
 
334
 
 
335
 
 
336
 
 
337
class MergePoem(TestBase):
 
338
    """Test case from diff3 manual"""
 
339
    def runTest(self):
298
340
        m3 = Merge3(TZU, LAO, TAO)
299
341
        ml = list(m3.merge_lines('LAO', 'TAO'))
300
342
        self.log('merge result:')
301
343
        self.log(''.join(ml))
302
344
        self.assertEquals(ml, MERGED_RESULT)
 
345
 
 
346
 
 
347
 
 
348
TEST_CLASSES = [
 
349
    NoChanges,
 
350
    FrontInsert,
 
351
    NullInsert,
 
352
    NoConflicts,
 
353
    AppendA,
 
354
    AppendB,
 
355
    AppendAgreement,
 
356
    AppendClash,
 
357
    InsertAgreement,
 
358
    InsertClash,
 
359
    ReplaceClash,
 
360
    ReplaceMulti,
 
361
    MergePoem,
 
362
    ]