~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to testweave.py

  • Committer: Martin Pool
  • Date: 2005-06-28 09:34:03 UTC
  • mto: This revision was merged to the branch mainline in revision 852.
  • Revision ID: mbp@sourcefrog.net-20050628093403-a6f1e9c41c192a14
Add test for replacement lines

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 by 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
 
 
19
 
 
20
"""test suite for weave algorithm"""
 
21
 
 
22
 
 
23
from testsweet import TestBase
 
24
from weave import Weave, VerInfo, WeaveFormatError
 
25
 
 
26
 
 
27
# texts for use in testing
 
28
TEXT_0 = ["Hello world"]
 
29
TEXT_1 = ["Hello world",
 
30
          "A second line"]
 
31
 
 
32
 
 
33
class Easy(TestBase):
 
34
    def runTest(self):
 
35
        k = Weave()
 
36
 
 
37
 
 
38
class StoreText(TestBase):
 
39
    """Store and retrieve a simple text."""
 
40
    def runTest(self):
 
41
        k = Weave()
 
42
        idx = k.add([], TEXT_0)
 
43
        self.assertEqual(k.get(idx), TEXT_0)
 
44
        self.assertEqual(idx, 0)
 
45
 
 
46
 
 
47
 
 
48
class AnnotateOne(TestBase):
 
49
    def runTest(self):
 
50
        k = Weave()
 
51
        k.add([], TEXT_0)
 
52
        self.assertEqual(k.annotate(0),
 
53
                         [(0, TEXT_0[0])])
 
54
 
 
55
 
 
56
class StoreTwo(TestBase):
 
57
    def runTest(self):
 
58
        k = Weave()
 
59
 
 
60
        idx = k.add([], TEXT_0)
 
61
        self.assertEqual(idx, 0)
 
62
 
 
63
        idx = k.add([], TEXT_1)
 
64
        self.assertEqual(idx, 1)
 
65
 
 
66
        self.assertEqual(k.get(0), TEXT_0)
 
67
        self.assertEqual(k.get(1), TEXT_1)
 
68
 
 
69
        k.dump(self.TEST_LOG)
 
70
 
 
71
 
 
72
 
 
73
class Delta1(TestBase):
 
74
    """Detection of changes prior to inserting new revision."""
 
75
    def runTest(self):
 
76
        return ########################## SKIPPED
 
77
        from pprint import pformat
 
78
 
 
79
        k = Weave()
 
80
        k.add([], ['line 1'])
 
81
 
 
82
        changes = list(k._delta(set([0]),
 
83
                                ['line 1',
 
84
                                 'new line']))
 
85
 
 
86
        self.log('raw changes: ' + pformat(changes))
 
87
 
 
88
        # should be one inserted line after line 0q
 
89
        self.assertEquals(changes,
 
90
                          [(1, 1, ['new line'])])
 
91
 
 
92
        changes = k._delta(set([0]),
 
93
                           ['top line',
 
94
                            'line 1'])
 
95
        
 
96
        self.assertEquals(list(changes),
 
97
                          [(0, 0, ['top line'])])
 
98
 
 
99
 
 
100
 
 
101
class InvalidAdd(TestBase):
 
102
    """Try to use invalid version number during add."""
 
103
    def runTest(self):
 
104
        k = Weave()
 
105
 
 
106
        self.assertRaises(IndexError,
 
107
                          k.add,
 
108
                          [69],
 
109
                          ['new text!'])
 
110
 
 
111
 
 
112
class InsertLines(TestBase):
 
113
    """Store a revision that adds one line to the original.
 
114
 
 
115
    Look at the annotations to make sure that the first line is matched
 
116
    and not stored repeatedly."""
 
117
    def runTest(self):
 
118
        return ########################## SKIPPED
 
119
        
 
120
        k = Weave()
 
121
 
 
122
        k.add([], ['line 1'])
 
123
        k.add([0], ['line 1', 'line 2'])
 
124
 
 
125
        self.assertEqual(k.annotate(0),
 
126
                         [(0, 'line 1')])
 
127
 
 
128
        self.assertEqual(k.get(1),
 
129
                         ['line 1',
 
130
                          'line 2'])
 
131
 
 
132
        self.assertEqual(k.annotate(1),
 
133
                         [(0, 'line 1'),
 
134
                          (1, 'line 2')])
 
135
 
 
136
        k.add([0], ['line 1', 'diverged line'])
 
137
 
 
138
        self.assertEqual(k.annotate(2),
 
139
                         [(0, 'line 1'),
 
140
                          (2, 'diverged line')])
 
141
 
 
142
        k.add([0, 1],
 
143
              ['line 1', 'middle line', 'line 2'])
 
144
 
 
145
        self.assertEqual(k.annotate(3),
 
146
                         [(0, 'line 1'),
 
147
                          (3, 'middle line'),
 
148
                          (1, 'line 2')])
 
149
 
 
150
        # now multiple insertions at different places
 
151
        k.add([0, 1, 3],
 
152
              ['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])
 
153
 
 
154
        self.assertEqual(k.annotate(4), 
 
155
                         [(0, 'line 1'),
 
156
                          (4, 'aaa'),
 
157
                          (3, 'middle line'),
 
158
                          (4, 'bbb'),
 
159
                          (1, 'line 2'),
 
160
                          (4, 'ccc')])
 
161
 
 
162
 
 
163
 
 
164
class SuicideDelete(TestBase):
 
165
    def runTest(self):
 
166
        k = Weave()
 
167
 
 
168
        k._v = [VerInfo([]),
 
169
                ]
 
170
        k._l = [('{', 0),
 
171
                'first line',
 
172
                ('[', 0),
 
173
                'deleted in 0',
 
174
                (']', 0),
 
175
                ('}', 0),
 
176
                ]
 
177
 
 
178
        self.assertRaises(WeaveFormatError,
 
179
                          k.get,
 
180
                          0)        
 
181
 
 
182
 
 
183
 
 
184
class CannedDelete(TestBase):
 
185
    """Unpack canned weave with deleted lines."""
 
186
    def runTest(self):
 
187
        k = Weave()
 
188
 
 
189
        k._v = [VerInfo([]),
 
190
                VerInfo([0]),
 
191
                ]
 
192
        k._l = [('{', 0),
 
193
                'first line',
 
194
                ('[', 1),
 
195
                'line to be deleted',
 
196
                (']', 1),
 
197
                'last line',
 
198
                ('}', 0),
 
199
                ]
 
200
 
 
201
        self.assertEqual(k.get(0),
 
202
                         ['first line',
 
203
                          'line to be deleted',
 
204
                          'last line',
 
205
                          ])
 
206
 
 
207
        self.assertEqual(k.get(1),
 
208
                         ['first line',
 
209
                          'last line',
 
210
                          ])
 
211
 
 
212
 
 
213
 
 
214
class CannedReplacement(TestBase):
 
215
    """Unpack canned weave with deleted lines."""
 
216
    def runTest(self):
 
217
        k = Weave()
 
218
 
 
219
        k._v = [VerInfo([]),
 
220
                VerInfo([0]),
 
221
                ]
 
222
        k._l = [('{', 0),
 
223
                'first line',
 
224
                ('[', 1),
 
225
                'line to be deleted',
 
226
                (']', 1),
 
227
                ('{', 1),
 
228
                'replacement line',                
 
229
                ('}', 1),
 
230
                'last line',
 
231
                ('}', 0),
 
232
                ]
 
233
 
 
234
        self.assertEqual(k.get(0),
 
235
                         ['first line',
 
236
                          'line to be deleted',
 
237
                          'last line',
 
238
                          ])
 
239
 
 
240
        self.assertEqual(k.get(1),
 
241
                         ['first line',
 
242
                          'replacement line',
 
243
                          'last line',
 
244
                          ])
 
245
 
 
246
 
 
247
 
 
248
class BadWeave(TestBase):
 
249
    """Test that we trap an insert which should not occur."""
 
250
    def runTest(self):
 
251
        k = Weave()
 
252
 
 
253
        k._v = [VerInfo([]),
 
254
                ]
 
255
        k._l = ['bad line',
 
256
                ('{', 0),
 
257
                'foo {',
 
258
                ('{', 1),
 
259
                '  added in version 1',
 
260
                ('{', 2),
 
261
                '  added in v2',
 
262
                ('}', 2),
 
263
                '  also from v1',
 
264
                ('}', 1),
 
265
                '}',
 
266
                ('}', 0)]
 
267
 
 
268
        self.assertRaises(WeaveFormatError,
 
269
                          k.get,
 
270
                          0)
 
271
 
 
272
 
 
273
class BadInsert(TestBase):
 
274
    """Test that we trap an insert which should not occur."""
 
275
    def runTest(self):
 
276
        k = Weave()
 
277
 
 
278
        k._v = [VerInfo([]),
 
279
                VerInfo([0]),
 
280
                VerInfo([0]),
 
281
                VerInfo([0,1,2]),
 
282
                ]
 
283
        k._l = [('{', 0),
 
284
                'foo {',
 
285
                ('{', 1),
 
286
                '  added in version 1',
 
287
                ('{', 1),
 
288
                '  more in 1',
 
289
                ('}', 1),
 
290
                ('}', 1),
 
291
                ('}', 0)]
 
292
 
 
293
        self.assertRaises(WeaveFormatError,
 
294
                          k.get,
 
295
                          0)
 
296
 
 
297
        self.assertRaises(WeaveFormatError,
 
298
                          k.get,
 
299
                          1)
 
300
 
 
301
 
 
302
class InsertNested(TestBase):
 
303
    """Insertion with nested instructions."""
 
304
    def runTest(self):
 
305
        k = Weave()
 
306
 
 
307
        k._v = [VerInfo([]),
 
308
                VerInfo([0]),
 
309
                VerInfo([0]),
 
310
                VerInfo([0,1,2]),
 
311
                ]
 
312
        k._l = [('{', 0),
 
313
                'foo {',
 
314
                ('{', 1),
 
315
                '  added in version 1',
 
316
                ('{', 2),
 
317
                '  added in v2',
 
318
                ('}', 2),
 
319
                '  also from v1',
 
320
                ('}', 1),
 
321
                '}',
 
322
                ('}', 0)]
 
323
 
 
324
        self.assertEqual(k.get(0),
 
325
                         ['foo {',
 
326
                          '}'])
 
327
 
 
328
        self.assertEqual(k.get(1),
 
329
                         ['foo {',
 
330
                          '  added in version 1',
 
331
                          '  also from v1',
 
332
                          '}'])
 
333
                       
 
334
        self.assertEqual(k.get(2),
 
335
                         ['foo {',
 
336
                          '  added in v2',
 
337
                          '}'])
 
338
 
 
339
        self.assertEqual(k.get(3),
 
340
                         ['foo {',
 
341
                          '  added in version 1',
 
342
                          '  added in v2',
 
343
                          '  also from v1',
 
344
                          '}'])
 
345
                         
 
346
 
 
347
 
 
348
class DeleteLines(TestBase):
 
349
    """Test recording revisions that delete lines.
 
350
 
 
351
    This relies on the weave having a way to represent lines knocked
 
352
    out by a later revision."""
 
353
    def runTest(self):
 
354
        k = Weave()
 
355
 
 
356
        k.add([], ["line the first",
 
357
                   "line 2",
 
358
                   "line 3",
 
359
                   "fine"])
 
360
 
 
361
        self.assertEqual(len(k.get(0)), 4)
 
362
 
 
363
        return ################################## SKIPPED
 
364
 
 
365
        k.add([0], ["line the first",
 
366
                   "fine"])
 
367
 
 
368
        self.assertEqual(k.get(1),
 
369
                         ["line the first",
 
370
                          "fine"])
 
371
 
 
372
 
 
373
 
 
374
class IncludeVersions(TestBase):
 
375
    """Check texts that are stored across multiple revisions.
 
376
 
 
377
    Here we manually create a weave with particular encoding and make
 
378
    sure it unpacks properly.
 
379
 
 
380
    Text 0 includes nothing; text 1 includes text 0 and adds some
 
381
    lines.
 
382
    """
 
383
 
 
384
    def runTest(self):
 
385
        k = Weave()
 
386
 
 
387
        k._v = [VerInfo(), VerInfo(included=[0])]
 
388
        k._l = [('{', 0),
 
389
                "first line",
 
390
                ('}', 0),
 
391
                ('{', 1),
 
392
                "second line",
 
393
                ('}', 1)]
 
394
 
 
395
        self.assertEqual(k.get(1),
 
396
                         ["first line",
 
397
                          "second line"])
 
398
 
 
399
        self.assertEqual(k.get(0),
 
400
                         ["first line"])
 
401
 
 
402
        k.dump(self.TEST_LOG)
 
403
 
 
404
 
 
405
class DivergedIncludes(TestBase):
 
406
    """Weave with two diverged texts based on version 0.
 
407
    """
 
408
    def runTest(self):
 
409
        k = Weave()
 
410
 
 
411
        k._v = [VerInfo(),
 
412
                VerInfo(included=[0]),
 
413
                VerInfo(included=[0]),
 
414
                ]
 
415
        k._l = [('{', 0),
 
416
                "first line",
 
417
                ('}', 0),
 
418
                ('{', 1),
 
419
                "second line",
 
420
                ('}', 1),
 
421
                ('{', 2),
 
422
                "alternative second line",
 
423
                ('}', 2),                
 
424
                ]
 
425
 
 
426
        self.assertEqual(k.get(0),
 
427
                         ["first line"])
 
428
 
 
429
        self.assertEqual(k.get(1),
 
430
                         ["first line",
 
431
                          "second line"])
 
432
 
 
433
        self.assertEqual(k.get(2),
 
434
                         ["first line",
 
435
                          "alternative second line"])
 
436
 
 
437
def testweave():
 
438
    import testsweet
 
439
    from unittest import TestSuite, TestLoader
 
440
    import testweave
 
441
 
 
442
    tl = TestLoader()
 
443
    suite = TestSuite()
 
444
    suite.addTest(tl.loadTestsFromModule(testweave))
 
445
    
 
446
    return int(not testsweet.run_suite(suite)) # for shell 0=true
 
447
 
 
448
 
 
449
if __name__ == '__main__':
 
450
    import sys
 
451
    sys.exit(testweave())
 
452