← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_merge3.py

  • Committer: John Arbash Meinel
  • Date: 2010-08-23 21:36:06 UTC
  • mto: This revision was merged to the branch mainline in revision 5390.
  • Revision ID: john@arbash-meinel.com-20100823213606-1pk5w1nyaz9kz9k0
Lots of compatibility changes for python2.4 and mingw32 compilers.

gcc has strtoll available, and does the wrong thing if you use _strtoi64 (it implicitly
defines it to return an 'int' which isn't a 64-bit integer.)

Further, python2.4 doesn't support the %lu syntax, only having %ld and %d. So we go
back to casting everything into real python objects and then stringifying them, but
only for python 2.4.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge3.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
from bzrlib.selftest import InTempDir, TestBase
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
from bzrlib import (
 
19
    errors,
 
20
    merge3,
 
21
    tests,
 
22
    )
19
23
from bzrlib.merge3 import Merge3
20
 
 
21
 
 
22
 
 
23
 
 
24
 
 
25
 
class NoChanges(TestBase):
26
 
    """No conflicts because nothing changed"""
27
 
    def runTest(self):
28
 
        m3 = Merge3(['aaa', 'bbb'],
29
 
                    ['aaa', 'bbb'],
30
 
                    ['aaa', 'bbb'])
 
24
from bzrlib.errors import CantReprocessAndShowBase, BinaryFile
 
25
 
 
26
def split_lines(t):
 
27
    from cStringIO import StringIO
 
28
    return StringIO(t).readlines()
 
29
 
 
30
############################################################
 
31
# test case data from the gnu diffutils manual
 
32
# common base
 
33
TZU = split_lines("""     The Nameless is the origin of Heaven and Earth;
 
34
     The named is the mother of all things.
 
35
 
 
36
     Therefore let there always be non-being,
 
37
       so we may see their subtlety,
 
38
     And let there always be being,
 
39
       so we may see their outcome.
 
40
     The two are the same,
 
41
     But after they are produced,
 
42
       they have different names.
 
43
     They both may be called deep and profound.
 
44
     Deeper and more profound,
 
45
     The door of all subtleties!
 
46
""")
 
47
 
 
48
LAO = split_lines("""     The Way that can be told of is not the eternal Way;
 
49
     The name that can be named is not the eternal name.
 
50
     The Nameless is the origin of Heaven and Earth;
 
51
     The Named is the mother of all things.
 
52
     Therefore let there always be non-being,
 
53
       so we may see their subtlety,
 
54
     And let there always be being,
 
55
       so we may see their outcome.
 
56
     The two are the same,
 
57
     But after they are produced,
 
58
       they have different names.
 
59
""")
 
60
 
 
61
 
 
62
TAO = split_lines("""     The Way that can be told of is not the eternal Way;
 
63
     The name that can be named is not the eternal name.
 
64
     The Nameless is the origin of Heaven and Earth;
 
65
     The named is the mother of all things.
 
66
 
 
67
     Therefore let there always be non-being,
 
68
       so we may see their subtlety,
 
69
     And let there always be being,
 
70
       so we may see their result.
 
71
     The two are the same,
 
72
     But after they are produced,
 
73
       they have different names.
 
74
 
 
75
       -- The Way of Lao-Tzu, tr. Wing-tsit Chan
 
76
 
 
77
""")
 
78
 
 
79
MERGED_RESULT = split_lines("""     The Way that can be told of is not the eternal Way;
 
80
     The name that can be named is not the eternal name.
 
81
     The Nameless is the origin of Heaven and Earth;
 
82
     The Named is the mother of all things.
 
83
     Therefore let there always be non-being,
 
84
       so we may see their subtlety,
 
85
     And let there always be being,
 
86
       so we may see their result.
 
87
     The two are the same,
 
88
     But after they are produced,
 
89
       they have different names.
 
90
<<<<<<< LAO
 
91
=======
 
92
 
 
93
       -- The Way of Lao-Tzu, tr. Wing-tsit Chan
 
94
 
 
95
>>>>>>> TAO
 
96
""")
 
97
 
 
98
class TestMerge3(tests.TestCase):
 
99
 
 
100
    def test_no_changes(self):
 
101
        """No conflicts because nothing changed"""
 
102
        m3 = merge3.Merge3(['aaa', 'bbb'],
 
103
                           ['aaa', 'bbb'],
 
104
                           ['aaa', 'bbb'])
31
105
 
32
106
        self.assertEquals(m3.find_unconflicted(),
33
107
                          [(0, 2)])
44
118
        self.assertEquals(list(m3.merge_groups()),
45
119
                          [('unchanged', ['aaa', 'bbb'])])
46
120
 
47
 
 
48
 
class FrontInsert(TestBase):
49
 
    def runTest(self):
50
 
        m3 = Merge3(['zz'],
51
 
                    ['aaa', 'bbb', 'zz'],
52
 
                    ['zz'])
 
121
    def test_front_insert(self):
 
122
        m3 = merge3.Merge3(['zz'],
 
123
                           ['aaa', 'bbb', 'zz'],
 
124
                           ['zz'])
53
125
 
54
126
        # todo: should use a sentinal at end as from get_matching_blocks
55
127
        # to match without zz
64
136
        self.assertEquals(list(m3.merge_groups()),
65
137
                          [('a', ['aaa', 'bbb']),
66
138
                           ('unchanged', ['zz'])])
67
 
        
68
 
    
69
 
 
70
 
class NullInsert(TestBase):
71
 
    def runTest(self):
72
 
        m3 = Merge3([],
73
 
                    ['aaa', 'bbb'],
74
 
                    [])
75
 
 
 
139
 
 
140
    def test_null_insert(self):
 
141
        m3 = merge3.Merge3([],
 
142
                           ['aaa', 'bbb'],
 
143
                           [])
76
144
        # todo: should use a sentinal at end as from get_matching_blocks
77
145
        # to match without zz
78
146
        self.assertEquals(list(m3.find_sync_regions()),
83
151
 
84
152
        self.assertEquals(list(m3.merge_lines()),
85
153
                          ['aaa', 'bbb'])
86
 
        
87
 
    
88
154
 
89
 
class NoConflicts(TestBase):
90
 
    """No conflicts because only one side changed"""
91
 
    def runTest(self):
92
 
        m3 = Merge3(['aaa', 'bbb'],
93
 
                    ['aaa', '111', 'bbb'],
94
 
                    ['aaa', 'bbb'])
 
155
    def test_no_conflicts(self):
 
156
        """No conflicts because only one side changed"""
 
157
        m3 = merge3.Merge3(['aaa', 'bbb'],
 
158
                           ['aaa', '111', 'bbb'],
 
159
                           ['aaa', 'bbb'])
95
160
 
96
161
        self.assertEquals(m3.find_unconflicted(),
97
162
                          [(0, 1), (1, 2)])
106
171
                           ('a', 1, 2),
107
172
                           ('unchanged', 1, 2),])
108
173
 
109
 
 
110
 
 
111
 
class AppendA(TestBase):
112
 
    def runTest(self):
113
 
        m3 = Merge3(['aaa\n', 'bbb\n'],
114
 
                    ['aaa\n', 'bbb\n', '222\n'],
115
 
                    ['aaa\n', 'bbb\n'])
116
 
 
117
 
        self.assertEquals(''.join(m3.merge_lines()),
118
 
                          'aaa\nbbb\n222\n')
119
 
 
120
 
class AppendB(TestBase):
121
 
    def runTest(self):
122
 
        m3 = Merge3(['aaa\n', 'bbb\n'],
123
 
                    ['aaa\n', 'bbb\n'],
124
 
                    ['aaa\n', 'bbb\n', '222\n'])
125
 
 
126
 
        self.assertEquals(''.join(m3.merge_lines()),
127
 
                          'aaa\nbbb\n222\n')
128
 
 
129
 
class AppendAgreement(TestBase):
130
 
    def runTest(self):
131
 
        m3 = Merge3(['aaa\n', 'bbb\n'],
132
 
                    ['aaa\n', 'bbb\n', '222\n'],
133
 
                    ['aaa\n', 'bbb\n', '222\n'])
134
 
 
135
 
        self.assertEquals(''.join(m3.merge_lines()),
136
 
                          'aaa\nbbb\n222\n')
137
 
 
138
 
class AppendClash(TestBase):
139
 
    def runTest(self):
140
 
        m3 = Merge3(['aaa\n', 'bbb\n'],
141
 
                    ['aaa\n', 'bbb\n', '222\n'],
142
 
                    ['aaa\n', 'bbb\n', '333\n'])
 
174
    def test_append_a(self):
 
175
        m3 = merge3.Merge3(['aaa\n', 'bbb\n'],
 
176
                           ['aaa\n', 'bbb\n', '222\n'],
 
177
                           ['aaa\n', 'bbb\n'])
 
178
 
 
179
        self.assertEquals(''.join(m3.merge_lines()),
 
180
                          'aaa\nbbb\n222\n')
 
181
 
 
182
    def test_append_b(self):
 
183
        m3 = merge3.Merge3(['aaa\n', 'bbb\n'],
 
184
                           ['aaa\n', 'bbb\n'],
 
185
                           ['aaa\n', 'bbb\n', '222\n'])
 
186
 
 
187
        self.assertEquals(''.join(m3.merge_lines()),
 
188
                          'aaa\nbbb\n222\n')
 
189
 
 
190
    def test_append_agreement(self):
 
191
        m3 = merge3.Merge3(['aaa\n', 'bbb\n'],
 
192
                           ['aaa\n', 'bbb\n', '222\n'],
 
193
                           ['aaa\n', 'bbb\n', '222\n'])
 
194
 
 
195
        self.assertEquals(''.join(m3.merge_lines()),
 
196
                          'aaa\nbbb\n222\n')
 
197
 
 
198
    def test_append_clash(self):
 
199
        m3 = merge3.Merge3(['aaa\n', 'bbb\n'],
 
200
                           ['aaa\n', 'bbb\n', '222\n'],
 
201
                           ['aaa\n', 'bbb\n', '333\n'])
143
202
 
144
203
        ml = m3.merge_lines(name_a='a',
145
204
                            name_b='b',
157
216
>> b
158
217
''')
159
218
 
160
 
 
161
 
class InsertAgreement(TestBase):
162
 
    def runTest(self):
163
 
        m3 = Merge3(['aaa\n', 'bbb\n'],
164
 
                    ['aaa\n', '222\n', 'bbb\n'],
165
 
                    ['aaa\n', '222\n', 'bbb\n'])
 
219
    def test_insert_agreement(self):
 
220
        m3 = merge3.Merge3(['aaa\n', 'bbb\n'],
 
221
                           ['aaa\n', '222\n', 'bbb\n'],
 
222
                           ['aaa\n', '222\n', 'bbb\n'])
166
223
 
167
224
        ml = m3.merge_lines(name_a='a',
168
225
                            name_b='b',
169
226
                            start_marker='<<',
170
227
                            mid_marker='--',
171
228
                            end_marker='>>')
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):
181
 
        m3 = Merge3(['aaa\n', 'bbb\n'],
182
 
                    ['aaa\n', '111\n', 'bbb\n'],
183
 
                    ['aaa\n', '222\n', 'bbb\n'])
 
229
        self.assertEquals(''.join(ml), 'aaa\n222\nbbb\n')
 
230
 
 
231
 
 
232
    def test_insert_clash(self):
 
233
        """Both try to insert lines in the same place."""
 
234
        m3 = merge3.Merge3(['aaa\n', 'bbb\n'],
 
235
                           ['aaa\n', '111\n', 'bbb\n'],
 
236
                           ['aaa\n', '222\n', 'bbb\n'])
184
237
 
185
238
        self.assertEquals(m3.find_unconflicted(),
186
239
                          [(0, 1), (1, 2)])
216
269
bbb
217
270
''')
218
271
 
219
 
 
220
 
 
221
 
class ReplaceClash(TestBase):
222
 
    """Both try to insert lines in the same place."""
223
 
    def runTest(self):
224
 
        m3 = Merge3(['aaa', '000', 'bbb'],
225
 
                    ['aaa', '111', 'bbb'],
226
 
                    ['aaa', '222', 'bbb'])
 
272
    def test_replace_clash(self):
 
273
        """Both try to insert lines in the same place."""
 
274
        m3 = merge3.Merge3(['aaa', '000', 'bbb'],
 
275
                           ['aaa', '111', 'bbb'],
 
276
                           ['aaa', '222', 'bbb'])
227
277
 
228
278
        self.assertEquals(m3.find_unconflicted(),
229
279
                          [(0, 1), (2, 3)])
233
283
                           (2,3, 2,3, 2,3),
234
284
                           (3,3, 3,3, 3,3),])
235
285
 
236
 
 
237
 
 
238
 
class ReplaceMulti(TestBase):
239
 
    """Replacement with regions of different size."""
240
 
    def runTest(self):
241
 
        m3 = Merge3(['aaa', '000', '000', 'bbb'],
242
 
                    ['aaa', '111', '111', '111', 'bbb'],
243
 
                    ['aaa', '222', '222', '222', '222', 'bbb'])
 
286
    def test_replace_multi(self):
 
287
        """Replacement with regions of different size."""
 
288
        m3 = merge3.Merge3(['aaa', '000', '000', 'bbb'],
 
289
                           ['aaa', '111', '111', '111', 'bbb'],
 
290
                           ['aaa', '222', '222', '222', '222', 'bbb'])
244
291
 
245
292
        self.assertEquals(m3.find_unconflicted(),
246
293
                          [(0, 1), (3, 4)])
251
298
                           (3,4, 4,5, 5,6),
252
299
                           (4,4, 5,5, 6,6),])
253
300
 
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):
340
 
        m3 = Merge3(TZU, LAO, TAO)
 
301
    def test_merge_poem(self):
 
302
        """Test case from diff3 manual"""
 
303
        m3 = merge3.Merge3(TZU, LAO, TAO)
341
304
        ml = list(m3.merge_lines('LAO', 'TAO'))
342
305
        self.log('merge result:')
343
306
        self.log(''.join(ml))
344
307
        self.assertEquals(ml, MERGED_RESULT)
345
308
 
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
 
    ]
 
309
    def test_minimal_conflicts_common(self):
 
310
        """Reprocessing"""
 
311
        base_text = ("a\n" * 20).splitlines(True)
 
312
        this_text = ("a\n"*10+"b\n" * 10).splitlines(True)
 
313
        other_text = ("a\n"*10+"c\n"+"b\n" * 8 + "c\n").splitlines(True)
 
314
        m3 = merge3.Merge3(base_text, other_text, this_text)
 
315
        m_lines = m3.merge_lines('OTHER', 'THIS', reprocess=True)
 
316
        merged_text = "".join(list(m_lines))
 
317
        optimal_text = ("a\n" * 10 + "<<<<<<< OTHER\nc\n"
 
318
            + 8* "b\n" + "c\n=======\n"
 
319
            + 10*"b\n" + ">>>>>>> THIS\n")
 
320
        self.assertEqualDiff(optimal_text, merged_text)
 
321
 
 
322
    def test_minimal_conflicts_unique(self):
 
323
        def add_newline(s):
 
324
            """Add a newline to each entry in the string"""
 
325
            return [(x+'\n') for x in s]
 
326
 
 
327
        base_text = add_newline("abcdefghijklm")
 
328
        this_text = add_newline("abcdefghijklmNOPQRSTUVWXYZ")
 
329
        other_text = add_newline("abcdefghijklm1OPQRSTUVWXY2")
 
330
        m3 = merge3.Merge3(base_text, other_text, this_text)
 
331
        m_lines = m3.merge_lines('OTHER', 'THIS', reprocess=True)
 
332
        merged_text = "".join(list(m_lines))
 
333
        optimal_text = ''.join(add_newline("abcdefghijklm")
 
334
            + ["<<<<<<< OTHER\n1\n=======\nN\n>>>>>>> THIS\n"]
 
335
            + add_newline('OPQRSTUVWXY')
 
336
            + ["<<<<<<< OTHER\n2\n=======\nZ\n>>>>>>> THIS\n"]
 
337
            )
 
338
        self.assertEqualDiff(optimal_text, merged_text)
 
339
 
 
340
    def test_minimal_conflicts_nonunique(self):
 
341
        def add_newline(s):
 
342
            """Add a newline to each entry in the string"""
 
343
            return [(x+'\n') for x in s]
 
344
 
 
345
        base_text = add_newline("abacddefgghij")
 
346
        this_text = add_newline("abacddefgghijkalmontfprz")
 
347
        other_text = add_newline("abacddefgghijknlmontfprd")
 
348
        m3 = merge3.Merge3(base_text, other_text, this_text)
 
349
        m_lines = m3.merge_lines('OTHER', 'THIS', reprocess=True)
 
350
        merged_text = "".join(list(m_lines))
 
351
        optimal_text = ''.join(add_newline("abacddefgghijk")
 
352
            + ["<<<<<<< OTHER\nn\n=======\na\n>>>>>>> THIS\n"]
 
353
            + add_newline('lmontfpr')
 
354
            + ["<<<<<<< OTHER\nd\n=======\nz\n>>>>>>> THIS\n"]
 
355
            )
 
356
        self.assertEqualDiff(optimal_text, merged_text)
 
357
 
 
358
    def test_reprocess_and_base(self):
 
359
        """Reprocessing and showing base breaks correctly"""
 
360
        base_text = ("a\n" * 20).splitlines(True)
 
361
        this_text = ("a\n"*10+"b\n" * 10).splitlines(True)
 
362
        other_text = ("a\n"*10+"c\n"+"b\n" * 8 + "c\n").splitlines(True)
 
363
        m3 = merge3.Merge3(base_text, other_text, this_text)
 
364
        m_lines = m3.merge_lines('OTHER', 'THIS', reprocess=True,
 
365
                                 base_marker='|||||||')
 
366
        self.assertRaises(CantReprocessAndShowBase, list, m_lines)
 
367
 
 
368
    def test_binary(self):
 
369
        self.assertRaises(BinaryFile, merge3.Merge3, ['\x00'], ['a'], ['b'])
 
370
 
 
371
    def test_dos_text(self):
 
372
        base_text = 'a\r\n'
 
373
        this_text = 'b\r\n'
 
374
        other_text = 'c\r\n'
 
375
        m3 = merge3.Merge3(base_text.splitlines(True),
 
376
                           other_text.splitlines(True),
 
377
                           this_text.splitlines(True))
 
378
        m_lines = m3.merge_lines('OTHER', 'THIS')
 
379
        self.assertEqual('<<<<<<< OTHER\r\nc\r\n=======\r\nb\r\n'
 
380
            '>>>>>>> THIS\r\n'.splitlines(True), list(m_lines))
 
381
 
 
382
    def test_mac_text(self):
 
383
        base_text = 'a\r'
 
384
        this_text = 'b\r'
 
385
        other_text = 'c\r'
 
386
        m3 = merge3.Merge3(base_text.splitlines(True),
 
387
                           other_text.splitlines(True),
 
388
                           this_text.splitlines(True))
 
389
        m_lines = m3.merge_lines('OTHER', 'THIS')
 
390
        self.assertEqual('<<<<<<< OTHER\rc\r=======\rb\r'
 
391
            '>>>>>>> THIS\r'.splitlines(True), list(m_lines))
 
392
 
 
393
    def test_merge3_cherrypick(self):
 
394
        base_text = "a\nb\n"
 
395
        this_text = "a\n"
 
396
        other_text = "a\nb\nc\n"
 
397
        # When cherrypicking, lines in base are not part of the conflict
 
398
        m3 = merge3.Merge3(base_text.splitlines(True),
 
399
                           this_text.splitlines(True),
 
400
                           other_text.splitlines(True), is_cherrypick=True)
 
401
        m_lines = m3.merge_lines()
 
402
        self.assertEqualDiff('a\n<<<<<<<\n=======\nc\n>>>>>>>\n',
 
403
                             ''.join(m_lines))
 
404
 
 
405
        # This is not symmetric
 
406
        m3 = merge3.Merge3(base_text.splitlines(True),
 
407
                           other_text.splitlines(True),
 
408
                           this_text.splitlines(True), is_cherrypick=True)
 
409
        m_lines = m3.merge_lines()
 
410
        self.assertEqualDiff('a\n<<<<<<<\nb\nc\n=======\n>>>>>>>\n',
 
411
                             ''.join(m_lines))
 
412
 
 
413
    def test_merge3_cherrypick_w_mixed(self):
 
414
        base_text = 'a\nb\nc\nd\ne\n'
 
415
        this_text = 'a\nb\nq\n'
 
416
        other_text = 'a\nb\nc\nd\nf\ne\ng\n'
 
417
        # When cherrypicking, lines in base are not part of the conflict
 
418
        m3 = merge3.Merge3(base_text.splitlines(True),
 
419
                           this_text.splitlines(True),
 
420
                           other_text.splitlines(True), is_cherrypick=True)
 
421
        m_lines = m3.merge_lines()
 
422
        self.assertEqualDiff('a\n'
 
423
                             'b\n'
 
424
                             '<<<<<<<\n'
 
425
                             'q\n'
 
426
                             '=======\n'
 
427
                             'f\n'
 
428
                             '>>>>>>>\n'
 
429
                             '<<<<<<<\n'
 
430
                             '=======\n'
 
431
                             'g\n'
 
432
                             '>>>>>>>\n',
 
433
                             ''.join(m_lines))
 
434
 
 
435
    def test_allow_objects(self):
 
436
        """Objects other than strs may be used with Merge3 when
 
437
        allow_objects=True.
 
438
        
 
439
        merge_groups and merge_regions work with non-str input.  Methods that
 
440
        return lines like merge_lines fail.
 
441
        """
 
442
        base = [(x,x) for x in 'abcde']
 
443
        a = [(x,x) for x in 'abcdef']
 
444
        b = [(x,x) for x in 'Zabcde']
 
445
        m3 = merge3.Merge3(base, a, b, allow_objects=True)
 
446
        self.assertEqual(
 
447
            [('b', 0, 1),
 
448
             ('unchanged', 0, 5),
 
449
             ('a', 5, 6)],
 
450
            list(m3.merge_regions()))
 
451
        self.assertEqual(
 
452
            [('b', [('Z', 'Z')]),
 
453
             ('unchanged', [(x,x) for x in 'abcde']),
 
454
             ('a', [('f', 'f')])],
 
455
            list(m3.merge_groups()))
 
456