/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_merge3.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge3.py
1
 
# Copyright (C) 2005-2011, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
 
from .. import (
 
18
from bzrlib import (
19
19
    merge3,
20
20
    tests,
21
21
    )
22
 
from ..errors import CantReprocessAndShowBase, BinaryFile
23
 
from ..sixish import (
24
 
    BytesIO,
25
 
    )
 
22
from bzrlib.errors import CantReprocessAndShowBase, BinaryFile
26
23
 
27
24
def split_lines(t):
28
 
    return BytesIO(t).readlines()
 
25
    from cStringIO import StringIO
 
26
    return StringIO(t).readlines()
29
27
 
30
28
############################################################
31
29
# test case data from the gnu diffutils manual
32
30
# common base
33
 
TZU = split_lines(b"""     The Nameless is the origin of Heaven and Earth;
 
31
TZU = split_lines("""     The Nameless is the origin of Heaven and Earth;
34
32
     The named is the mother of all things.
35
33
 
36
34
     Therefore let there always be non-being,
45
43
     The door of all subtleties!
46
44
""")
47
45
 
48
 
LAO = split_lines(b"""     The Way that can be told of is not the eternal Way;
 
46
LAO = split_lines("""     The Way that can be told of is not the eternal Way;
49
47
     The name that can be named is not the eternal name.
50
48
     The Nameless is the origin of Heaven and Earth;
51
49
     The Named is the mother of all things.
59
57
""")
60
58
 
61
59
 
62
 
TAO = split_lines(b"""     The Way that can be told of is not the eternal Way;
 
60
TAO = split_lines("""     The Way that can be told of is not the eternal Way;
63
61
     The name that can be named is not the eternal name.
64
62
     The Nameless is the origin of Heaven and Earth;
65
63
     The named is the mother of all things.
76
74
 
77
75
""")
78
76
 
79
 
MERGED_RESULT = split_lines(b"""     The Way that can be told of is not the eternal Way;
 
77
MERGED_RESULT = split_lines("""     The Way that can be told of is not the eternal Way;
80
78
     The name that can be named is not the eternal name.
81
79
     The Nameless is the origin of Heaven and Earth;
82
80
     The Named is the mother of all things.
103
101
                           ['aaa', 'bbb'],
104
102
                           ['aaa', 'bbb'])
105
103
 
106
 
        self.assertEqual(m3.find_unconflicted(),
 
104
        self.assertEquals(m3.find_unconflicted(),
107
105
                          [(0, 2)])
108
106
 
109
 
        self.assertEqual(list(m3.find_sync_regions()),
 
107
        self.assertEquals(list(m3.find_sync_regions()),
110
108
                          [(0, 2,
111
109
                            0, 2,
112
110
                            0, 2),
113
 
                           (2, 2, 2, 2, 2, 2)])
 
111
                           (2,2, 2,2, 2,2)])
114
112
 
115
 
        self.assertEqual(list(m3.merge_regions()),
 
113
        self.assertEquals(list(m3.merge_regions()),
116
114
                          [('unchanged', 0, 2)])
117
115
 
118
 
        self.assertEqual(list(m3.merge_groups()),
 
116
        self.assertEquals(list(m3.merge_groups()),
119
117
                          [('unchanged', ['aaa', 'bbb'])])
120
118
 
121
119
    def test_front_insert(self):
125
123
 
126
124
        # todo: should use a sentinal at end as from get_matching_blocks
127
125
        # to match without zz
128
 
        self.assertEqual(list(m3.find_sync_regions()),
129
 
                          [(0, 1, 2, 3, 0, 1),
130
 
                           (1, 1, 3, 3, 1, 1),])
 
126
        self.assertEquals(list(m3.find_sync_regions()),
 
127
                          [(0,1, 2,3, 0,1),
 
128
                           (1,1, 3,3, 1,1),])
131
129
 
132
 
        self.assertEqual(list(m3.merge_regions()),
 
130
        self.assertEquals(list(m3.merge_regions()),
133
131
                          [('a', 0, 2),
134
132
                           ('unchanged', 0, 1)])
135
133
 
136
 
        self.assertEqual(list(m3.merge_groups()),
 
134
        self.assertEquals(list(m3.merge_groups()),
137
135
                          [('a', ['aaa', 'bbb']),
138
136
                           ('unchanged', ['zz'])])
139
137
 
143
141
                           [])
144
142
        # todo: should use a sentinal at end as from get_matching_blocks
145
143
        # to match without zz
146
 
        self.assertEqual(list(m3.find_sync_regions()),
147
 
                          [(0, 0, 2, 2, 0, 0)])
 
144
        self.assertEquals(list(m3.find_sync_regions()),
 
145
                          [(0,0, 2,2, 0,0)])
148
146
 
149
 
        self.assertEqual(list(m3.merge_regions()),
 
147
        self.assertEquals(list(m3.merge_regions()),
150
148
                          [('a', 0, 2)])
151
149
 
152
 
        self.assertEqual(list(m3.merge_lines()),
 
150
        self.assertEquals(list(m3.merge_lines()),
153
151
                          ['aaa', 'bbb'])
154
152
 
155
153
    def test_no_conflicts(self):
158
156
                           ['aaa', '111', 'bbb'],
159
157
                           ['aaa', 'bbb'])
160
158
 
161
 
        self.assertEqual(m3.find_unconflicted(),
 
159
        self.assertEquals(m3.find_unconflicted(),
162
160
                          [(0, 1), (1, 2)])
163
161
 
164
 
        self.assertEqual(list(m3.find_sync_regions()),
165
 
                          [(0, 1, 0, 1, 0, 1),
166
 
                           (1, 2, 2, 3, 1, 2),
167
 
                           (2, 2, 3, 3, 2, 2),])
 
162
        self.assertEquals(list(m3.find_sync_regions()),
 
163
                          [(0,1, 0,1, 0,1),
 
164
                           (1,2, 2,3, 1,2),
 
165
                           (2,2, 3,3, 2,2),])
168
166
 
169
 
        self.assertEqual(list(m3.merge_regions()),
 
167
        self.assertEquals(list(m3.merge_regions()),
170
168
                          [('unchanged', 0, 1),
171
169
                           ('a', 1, 2),
172
170
                           ('unchanged', 1, 2),])
176
174
                           ['aaa\n', 'bbb\n', '222\n'],
177
175
                           ['aaa\n', 'bbb\n'])
178
176
 
179
 
        self.assertEqual(''.join(m3.merge_lines()),
 
177
        self.assertEquals(''.join(m3.merge_lines()),
180
178
                          'aaa\nbbb\n222\n')
181
179
 
182
180
    def test_append_b(self):
184
182
                           ['aaa\n', 'bbb\n'],
185
183
                           ['aaa\n', 'bbb\n', '222\n'])
186
184
 
187
 
        self.assertEqual(''.join(m3.merge_lines()),
 
185
        self.assertEquals(''.join(m3.merge_lines()),
188
186
                          'aaa\nbbb\n222\n')
189
187
 
190
188
    def test_append_agreement(self):
192
190
                           ['aaa\n', 'bbb\n', '222\n'],
193
191
                           ['aaa\n', 'bbb\n', '222\n'])
194
192
 
195
 
        self.assertEqual(''.join(m3.merge_lines()),
 
193
        self.assertEquals(''.join(m3.merge_lines()),
196
194
                          'aaa\nbbb\n222\n')
197
195
 
198
196
    def test_append_clash(self):
205
203
                            start_marker='<<',
206
204
                            mid_marker='--',
207
205
                            end_marker='>>')
208
 
        self.assertEqual(''.join(ml),
 
206
        self.assertEquals(''.join(ml),
209
207
'''\
210
208
aaa
211
209
bbb
226
224
                            start_marker='<<',
227
225
                            mid_marker='--',
228
226
                            end_marker='>>')
229
 
        self.assertEqual(''.join(ml), 'aaa\n222\nbbb\n')
 
227
        self.assertEquals(''.join(ml), 'aaa\n222\nbbb\n')
230
228
 
231
229
 
232
230
    def test_insert_clash(self):
235
233
                           ['aaa\n', '111\n', 'bbb\n'],
236
234
                           ['aaa\n', '222\n', 'bbb\n'])
237
235
 
238
 
        self.assertEqual(m3.find_unconflicted(),
 
236
        self.assertEquals(m3.find_unconflicted(),
239
237
                          [(0, 1), (1, 2)])
240
238
 
241
 
        self.assertEqual(list(m3.find_sync_regions()),
242
 
                          [(0, 1, 0, 1, 0, 1),
243
 
                           (1, 2, 2, 3, 2, 3),
244
 
                           (2, 2, 3, 3, 3, 3),])
245
 
 
246
 
        self.assertEqual(list(m3.merge_regions()),
247
 
                          [('unchanged', 0, 1),
248
 
                           ('conflict', 1, 1, 1, 2, 1, 2),
249
 
                           ('unchanged', 1, 2)])
250
 
 
251
 
        self.assertEqual(list(m3.merge_groups()),
 
239
        self.assertEquals(list(m3.find_sync_regions()),
 
240
                          [(0,1, 0,1, 0,1),
 
241
                           (1,2, 2,3, 2,3),
 
242
                           (2,2, 3,3, 3,3),])
 
243
 
 
244
        self.assertEquals(list(m3.merge_regions()),
 
245
                          [('unchanged', 0,1),
 
246
                           ('conflict', 1,1, 1,2, 1,2),
 
247
                           ('unchanged', 1,2)])
 
248
 
 
249
        self.assertEquals(list(m3.merge_groups()),
252
250
                          [('unchanged', ['aaa\n']),
253
251
                           ('conflict', [], ['111\n'], ['222\n']),
254
252
                           ('unchanged', ['bbb\n']),
259
257
                            start_marker='<<',
260
258
                            mid_marker='--',
261
259
                            end_marker='>>')
262
 
        self.assertEqual(''.join(ml),
 
260
        self.assertEquals(''.join(ml),
263
261
'''aaa
264
262
<< a
265
263
111
275
273
                           ['aaa', '111', 'bbb'],
276
274
                           ['aaa', '222', 'bbb'])
277
275
 
278
 
        self.assertEqual(m3.find_unconflicted(),
 
276
        self.assertEquals(m3.find_unconflicted(),
279
277
                          [(0, 1), (2, 3)])
280
278
 
281
 
        self.assertEqual(list(m3.find_sync_regions()),
282
 
                          [(0, 1, 0, 1, 0, 1),
283
 
                           (2, 3, 2, 3, 2, 3),
284
 
                           (3, 3, 3, 3, 3, 3),])
 
279
        self.assertEquals(list(m3.find_sync_regions()),
 
280
                          [(0,1, 0,1, 0,1),
 
281
                           (2,3, 2,3, 2,3),
 
282
                           (3,3, 3,3, 3,3),])
285
283
 
286
284
    def test_replace_multi(self):
287
285
        """Replacement with regions of different size."""
289
287
                           ['aaa', '111', '111', '111', 'bbb'],
290
288
                           ['aaa', '222', '222', '222', '222', 'bbb'])
291
289
 
292
 
        self.assertEqual(m3.find_unconflicted(),
 
290
        self.assertEquals(m3.find_unconflicted(),
293
291
                          [(0, 1), (3, 4)])
294
292
 
295
293
 
296
 
        self.assertEqual(list(m3.find_sync_regions()),
297
 
                          [(0, 1, 0, 1, 0, 1),
298
 
                           (3, 4, 4, 5, 5, 6),
299
 
                           (4, 4, 5, 5, 6, 6),])
 
294
        self.assertEquals(list(m3.find_sync_regions()),
 
295
                          [(0,1, 0,1, 0,1),
 
296
                           (3,4, 4,5, 5,6),
 
297
                           (4,4, 5,5, 6,6),])
300
298
 
301
299
    def test_merge_poem(self):
302
300
        """Test case from diff3 manual"""
304
302
        ml = list(m3.merge_lines('LAO', 'TAO'))
305
303
        self.log('merge result:')
306
304
        self.log(''.join(ml))
307
 
        self.assertEqual(ml, MERGED_RESULT)
 
305
        self.assertEquals(ml, MERGED_RESULT)
308
306
 
309
307
    def test_minimal_conflicts_common(self):
310
308
        """Reprocessing"""
439
437
        merge_groups and merge_regions work with non-str input.  Methods that
440
438
        return lines like merge_lines fail.
441
439
        """
442
 
        base = [(x, x) for x in 'abcde']
443
 
        a = [(x, x) for x in 'abcdef']
444
 
        b = [(x, x) for x in 'Zabcde']
 
440
        base = [(x,x) for x in 'abcde']
 
441
        a = [(x,x) for x in 'abcdef']
 
442
        b = [(x,x) for x in 'Zabcde']
445
443
        m3 = merge3.Merge3(base, a, b, allow_objects=True)
446
444
        self.assertEqual(
447
445
            [('b', 0, 1),
450
448
            list(m3.merge_regions()))
451
449
        self.assertEqual(
452
450
            [('b', [('Z', 'Z')]),
453
 
             ('unchanged', [(x, x) for x in 'abcde']),
 
451
             ('unchanged', [(x,x) for x in 'abcde']),
454
452
             ('a', [('f', 'f')])],
455
453
            list(m3.merge_groups()))
456
454