← 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: Vincent Ladeuil
  • Date: 2008-01-29 08:40:53 UTC
  • mto: (3206.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 3207.
  • Revision ID: v.ladeuil+lp@free.fr-20080129084053-sunwf549ox6zczqr
Fix two more leaked log files.

* bzrlib/tests/test_http.py:
(TestHttpProxyWhiteBox.tearDown): Call the base class tearDown.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge3.py
 
1
# Copyright (C) 2004, 2005 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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.tests import TestCaseInTempDir, TestCase
 
19
from bzrlib.merge3 import Merge3
 
20
from bzrlib.errors import CantReprocessAndShowBase, BinaryFile
 
21
 
 
22
def split_lines(t):
 
23
    from cStringIO import StringIO
 
24
    return StringIO(t).readlines()
 
25
 
 
26
############################################################
 
27
# test case data from the gnu diffutils manual
 
28
# common base
 
29
TZU = split_lines("""     The Nameless is the origin of Heaven and Earth;
 
30
     The named is the mother of all things.
 
31
     
 
32
     Therefore let there always be non-being,
 
33
       so we may see their subtlety,
 
34
     And let there always be being,
 
35
       so we may see their outcome.
 
36
     The two are the same,
 
37
     But after they are produced,
 
38
       they have different names.
 
39
     They both may be called deep and profound.
 
40
     Deeper and more profound,
 
41
     The door of all subtleties!
 
42
""")
 
43
 
 
44
LAO = split_lines("""     The Way that can be told of is not the eternal Way;
 
45
     The name that can be named is not the eternal name.
 
46
     The Nameless is the origin of Heaven and Earth;
 
47
     The Named is the mother of all things.
 
48
     Therefore let there always be non-being,
 
49
       so we may see their subtlety,
 
50
     And let there always be being,
 
51
       so we may see their outcome.
 
52
     The two are the same,
 
53
     But after they are produced,
 
54
       they have different names.
 
55
""")
 
56
 
 
57
 
 
58
TAO = split_lines("""     The Way that can be told of is not the eternal Way;
 
59
     The name that can be named is not the eternal name.
 
60
     The Nameless is the origin of Heaven and Earth;
 
61
     The named is the mother of all things.
 
62
     
 
63
     Therefore let there always be non-being,
 
64
       so we may see their subtlety,
 
65
     And let there always be being,
 
66
       so we may see their result.
 
67
     The two are the same,
 
68
     But after they are produced,
 
69
       they have different names.
 
70
     
 
71
       -- The Way of Lao-Tzu, tr. Wing-tsit Chan
 
72
 
 
73
""")
 
74
 
 
75
MERGED_RESULT = split_lines("""     The Way that can be told of is not the eternal Way;
 
76
     The name that can be named is not the eternal name.
 
77
     The Nameless is the origin of Heaven and Earth;
 
78
     The Named is the mother of all things.
 
79
     Therefore let there always be non-being,
 
80
       so we may see their subtlety,
 
81
     And let there always be being,
 
82
       so we may see their result.
 
83
     The two are the same,
 
84
     But after they are produced,
 
85
       they have different names.
 
86
<<<<<<< LAO
 
87
=======
 
88
     
 
89
       -- The Way of Lao-Tzu, tr. Wing-tsit Chan
 
90
 
 
91
>>>>>>> TAO
 
92
""")
 
93
 
 
94
class TestMerge3(TestCase):
 
95
 
 
96
    def test_no_changes(self):
 
97
        """No conflicts because nothing changed"""
 
98
        m3 = Merge3(['aaa', 'bbb'],
 
99
                    ['aaa', 'bbb'],
 
100
                    ['aaa', 'bbb'])
 
101
 
 
102
        self.assertEquals(m3.find_unconflicted(),
 
103
                          [(0, 2)])
 
104
 
 
105
        self.assertEquals(list(m3.find_sync_regions()),
 
106
                          [(0, 2,
 
107
                            0, 2,
 
108
                            0, 2),
 
109
                           (2,2, 2,2, 2,2)])
 
110
 
 
111
        self.assertEquals(list(m3.merge_regions()),
 
112
                          [('unchanged', 0, 2)])
 
113
 
 
114
        self.assertEquals(list(m3.merge_groups()),
 
115
                          [('unchanged', ['aaa', 'bbb'])])
 
116
 
 
117
    def test_front_insert(self):
 
118
        m3 = Merge3(['zz'],
 
119
                    ['aaa', 'bbb', 'zz'],
 
120
                    ['zz'])
 
121
 
 
122
        # todo: should use a sentinal at end as from get_matching_blocks
 
123
        # to match without zz
 
124
        self.assertEquals(list(m3.find_sync_regions()),
 
125
                          [(0,1, 2,3, 0,1),
 
126
                           (1,1, 3,3, 1,1),])
 
127
 
 
128
        self.assertEquals(list(m3.merge_regions()),
 
129
                          [('a', 0, 2),
 
130
                           ('unchanged', 0, 1)])
 
131
 
 
132
        self.assertEquals(list(m3.merge_groups()),
 
133
                          [('a', ['aaa', 'bbb']),
 
134
                           ('unchanged', ['zz'])])
 
135
        
 
136
    def test_null_insert(self):
 
137
        m3 = Merge3([],
 
138
                    ['aaa', 'bbb'],
 
139
                    [])
 
140
        # todo: should use a sentinal at end as from get_matching_blocks
 
141
        # to match without zz
 
142
        self.assertEquals(list(m3.find_sync_regions()),
 
143
                          [(0,0, 2,2, 0,0)])
 
144
 
 
145
        self.assertEquals(list(m3.merge_regions()),
 
146
                          [('a', 0, 2)])
 
147
 
 
148
        self.assertEquals(list(m3.merge_lines()),
 
149
                          ['aaa', 'bbb'])
 
150
 
 
151
    def test_no_conflicts(self):
 
152
        """No conflicts because only one side changed"""
 
153
        m3 = Merge3(['aaa', 'bbb'],
 
154
                    ['aaa', '111', 'bbb'],
 
155
                    ['aaa', 'bbb'])
 
156
 
 
157
        self.assertEquals(m3.find_unconflicted(),
 
158
                          [(0, 1), (1, 2)])
 
159
 
 
160
        self.assertEquals(list(m3.find_sync_regions()),
 
161
                          [(0,1, 0,1, 0,1),
 
162
                           (1,2, 2,3, 1,2),
 
163
                           (2,2, 3,3, 2,2),])
 
164
 
 
165
        self.assertEquals(list(m3.merge_regions()),
 
166
                          [('unchanged', 0, 1),
 
167
                           ('a', 1, 2),
 
168
                           ('unchanged', 1, 2),])
 
169
 
 
170
    def test_append_a(self):
 
171
        m3 = Merge3(['aaa\n', 'bbb\n'],
 
172
                    ['aaa\n', 'bbb\n', '222\n'],
 
173
                    ['aaa\n', 'bbb\n'])
 
174
 
 
175
        self.assertEquals(''.join(m3.merge_lines()),
 
176
                          'aaa\nbbb\n222\n')
 
177
 
 
178
    def test_append_b(self):
 
179
        m3 = Merge3(['aaa\n', 'bbb\n'],
 
180
                    ['aaa\n', 'bbb\n'],
 
181
                    ['aaa\n', 'bbb\n', '222\n'])
 
182
 
 
183
        self.assertEquals(''.join(m3.merge_lines()),
 
184
                          'aaa\nbbb\n222\n')
 
185
 
 
186
    def test_append_agreement(self):
 
187
        m3 = Merge3(['aaa\n', 'bbb\n'],
 
188
                    ['aaa\n', 'bbb\n', '222\n'],
 
189
                    ['aaa\n', 'bbb\n', '222\n'])
 
190
 
 
191
        self.assertEquals(''.join(m3.merge_lines()),
 
192
                          'aaa\nbbb\n222\n')
 
193
 
 
194
    def test_append_clash(self):
 
195
        m3 = Merge3(['aaa\n', 'bbb\n'],
 
196
                    ['aaa\n', 'bbb\n', '222\n'],
 
197
                    ['aaa\n', 'bbb\n', '333\n'])
 
198
 
 
199
        ml = m3.merge_lines(name_a='a',
 
200
                            name_b='b',
 
201
                            start_marker='<<',
 
202
                            mid_marker='--',
 
203
                            end_marker='>>')
 
204
        self.assertEquals(''.join(ml),
 
205
'''\
 
206
aaa
 
207
bbb
 
208
<< a
 
209
222
 
210
--
 
211
333
 
212
>> b
 
213
''')
 
214
 
 
215
    def test_insert_agreement(self):
 
216
        m3 = Merge3(['aaa\n', 'bbb\n'],
 
217
                    ['aaa\n', '222\n', 'bbb\n'],
 
218
                    ['aaa\n', '222\n', 'bbb\n'])
 
219
 
 
220
        ml = m3.merge_lines(name_a='a',
 
221
                            name_b='b',
 
222
                            start_marker='<<',
 
223
                            mid_marker='--',
 
224
                            end_marker='>>')
 
225
        self.assertEquals(''.join(ml), 'aaa\n222\nbbb\n')
 
226
        
 
227
 
 
228
    def test_insert_clash(self):
 
229
        """Both try to insert lines in the same place."""
 
230
        m3 = Merge3(['aaa\n', 'bbb\n'],
 
231
                    ['aaa\n', '111\n', 'bbb\n'],
 
232
                    ['aaa\n', '222\n', 'bbb\n'])
 
233
 
 
234
        self.assertEquals(m3.find_unconflicted(),
 
235
                          [(0, 1), (1, 2)])
 
236
 
 
237
        self.assertEquals(list(m3.find_sync_regions()),
 
238
                          [(0,1, 0,1, 0,1),
 
239
                           (1,2, 2,3, 2,3),
 
240
                           (2,2, 3,3, 3,3),])
 
241
 
 
242
        self.assertEquals(list(m3.merge_regions()),
 
243
                          [('unchanged', 0,1),
 
244
                           ('conflict', 1,1, 1,2, 1,2),
 
245
                           ('unchanged', 1,2)])
 
246
 
 
247
        self.assertEquals(list(m3.merge_groups()),
 
248
                          [('unchanged', ['aaa\n']),
 
249
                           ('conflict', [], ['111\n'], ['222\n']),
 
250
                           ('unchanged', ['bbb\n']),
 
251
                           ])
 
252
 
 
253
        ml = m3.merge_lines(name_a='a',
 
254
                            name_b='b',
 
255
                            start_marker='<<',
 
256
                            mid_marker='--',
 
257
                            end_marker='>>')
 
258
        self.assertEquals(''.join(ml),
 
259
'''aaa
 
260
<< a
 
261
111
 
262
--
 
263
222
 
264
>> b
 
265
bbb
 
266
''')
 
267
 
 
268
    def test_replace_clash(self):
 
269
        """Both try to insert lines in the same place."""
 
270
        m3 = Merge3(['aaa', '000', 'bbb'],
 
271
                    ['aaa', '111', 'bbb'],
 
272
                    ['aaa', '222', 'bbb'])
 
273
 
 
274
        self.assertEquals(m3.find_unconflicted(),
 
275
                          [(0, 1), (2, 3)])
 
276
 
 
277
        self.assertEquals(list(m3.find_sync_regions()),
 
278
                          [(0,1, 0,1, 0,1),
 
279
                           (2,3, 2,3, 2,3),
 
280
                           (3,3, 3,3, 3,3),])
 
281
 
 
282
    def test_replace_multi(self):
 
283
        """Replacement with regions of different size."""
 
284
        m3 = Merge3(['aaa', '000', '000', 'bbb'],
 
285
                    ['aaa', '111', '111', '111', 'bbb'],
 
286
                    ['aaa', '222', '222', '222', '222', 'bbb'])
 
287
 
 
288
        self.assertEquals(m3.find_unconflicted(),
 
289
                          [(0, 1), (3, 4)])
 
290
 
 
291
 
 
292
        self.assertEquals(list(m3.find_sync_regions()),
 
293
                          [(0,1, 0,1, 0,1),
 
294
                           (3,4, 4,5, 5,6),
 
295
                           (4,4, 5,5, 6,6),])
 
296
 
 
297
    def test_merge_poem(self):
 
298
        """Test case from diff3 manual"""
 
299
        m3 = Merge3(TZU, LAO, TAO)
 
300
        ml = list(m3.merge_lines('LAO', 'TAO'))
 
301
        self.log('merge result:')
 
302
        self.log(''.join(ml))
 
303
        self.assertEquals(ml, MERGED_RESULT)
 
304
 
 
305
    def test_minimal_conflicts_common(self):
 
306
        """Reprocessing"""
 
307
        base_text = ("a\n" * 20).splitlines(True)
 
308
        this_text = ("a\n"*10+"b\n" * 10).splitlines(True)
 
309
        other_text = ("a\n"*10+"c\n"+"b\n" * 8 + "c\n").splitlines(True)
 
310
        m3 = Merge3(base_text, other_text, this_text)
 
311
        m_lines = m3.merge_lines('OTHER', 'THIS', reprocess=True)
 
312
        merged_text = "".join(list(m_lines))
 
313
        optimal_text = ("a\n" * 10 + "<<<<<<< OTHER\nc\n"
 
314
            + 8* "b\n" + "c\n=======\n"
 
315
            + 10*"b\n" + ">>>>>>> THIS\n")
 
316
        self.assertEqualDiff(optimal_text, merged_text)
 
317
 
 
318
    def test_minimal_conflicts_unique(self):
 
319
        def add_newline(s):
 
320
            """Add a newline to each entry in the string"""
 
321
            return [(x+'\n') for x in s]
 
322
 
 
323
        base_text = add_newline("abcdefghijklm")
 
324
        this_text = add_newline("abcdefghijklmNOPQRSTUVWXYZ")
 
325
        other_text = add_newline("abcdefghijklm1OPQRSTUVWXY2")
 
326
        m3 = Merge3(base_text, other_text, this_text)
 
327
        m_lines = m3.merge_lines('OTHER', 'THIS', reprocess=True)
 
328
        merged_text = "".join(list(m_lines))
 
329
        optimal_text = ''.join(add_newline("abcdefghijklm")
 
330
            + ["<<<<<<< OTHER\n1\n=======\nN\n>>>>>>> THIS\n"]
 
331
            + add_newline('OPQRSTUVWXY')
 
332
            + ["<<<<<<< OTHER\n2\n=======\nZ\n>>>>>>> THIS\n"]
 
333
            )
 
334
        self.assertEqualDiff(optimal_text, merged_text)
 
335
 
 
336
    def test_minimal_conflicts_nonunique(self):
 
337
        def add_newline(s):
 
338
            """Add a newline to each entry in the string"""
 
339
            return [(x+'\n') for x in s]
 
340
 
 
341
        base_text = add_newline("abacddefgghij")
 
342
        this_text = add_newline("abacddefgghijkalmontfprz")
 
343
        other_text = add_newline("abacddefgghijknlmontfprd")
 
344
        m3 = Merge3(base_text, other_text, this_text)
 
345
        m_lines = m3.merge_lines('OTHER', 'THIS', reprocess=True)
 
346
        merged_text = "".join(list(m_lines))
 
347
        optimal_text = ''.join(add_newline("abacddefgghijk")
 
348
            + ["<<<<<<< OTHER\nn\n=======\na\n>>>>>>> THIS\n"]
 
349
            + add_newline('lmontfpr')
 
350
            + ["<<<<<<< OTHER\nd\n=======\nz\n>>>>>>> THIS\n"]
 
351
            )
 
352
        self.assertEqualDiff(optimal_text, merged_text)
 
353
 
 
354
    def test_reprocess_and_base(self):
 
355
        """Reprocessing and showing base breaks correctly"""
 
356
        base_text = ("a\n" * 20).splitlines(True)
 
357
        this_text = ("a\n"*10+"b\n" * 10).splitlines(True)
 
358
        other_text = ("a\n"*10+"c\n"+"b\n" * 8 + "c\n").splitlines(True)
 
359
        m3 = Merge3(base_text, other_text, this_text)
 
360
        m_lines = m3.merge_lines('OTHER', 'THIS', reprocess=True, 
 
361
                                 base_marker='|||||||')
 
362
        self.assertRaises(CantReprocessAndShowBase, list, m_lines)
 
363
 
 
364
    def test_binary(self):
 
365
        self.assertRaises(BinaryFile, Merge3, ['\x00'], ['a'], ['b'])
 
366
 
 
367
    def test_dos_text(self):
 
368
        base_text = 'a\r\n'
 
369
        this_text = 'b\r\n'
 
370
        other_text = 'c\r\n'
 
371
        m3 = Merge3(base_text.splitlines(True), other_text.splitlines(True),
 
372
                    this_text.splitlines(True))
 
373
        m_lines = m3.merge_lines('OTHER', 'THIS')
 
374
        self.assertEqual('<<<<<<< OTHER\r\nc\r\n=======\r\nb\r\n'
 
375
            '>>>>>>> THIS\r\n'.splitlines(True), list(m_lines))
 
376
 
 
377
    def test_mac_text(self):
 
378
        base_text = 'a\r'
 
379
        this_text = 'b\r'
 
380
        other_text = 'c\r'
 
381
        m3 = Merge3(base_text.splitlines(True), other_text.splitlines(True),
 
382
                    this_text.splitlines(True))
 
383
        m_lines = m3.merge_lines('OTHER', 'THIS')
 
384
        self.assertEqual('<<<<<<< OTHER\rc\r=======\rb\r'
 
385
            '>>>>>>> THIS\r'.splitlines(True), list(m_lines))