← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/test_weave.py

  • Committer: Martin Pool
  • Date: 2005-09-22 06:19:33 UTC
  • Revision ID: mbp@sourcefrog.net-20050922061933-4b71d0f1e205b153
- keep track of number of checked revisions

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/test_weave.py
17
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 
19
19
 
 
20
# TODO: tests regarding version names
 
21
 
20
22
 
21
23
 
22
24
"""test suite for weave algorithm"""
23
25
 
 
26
from pprint import pformat
24
27
 
25
28
import testsweet
26
 
from bzrlib.weave import Weave, WeaveFormatError
 
29
from bzrlib.weave import Weave, WeaveFormatError, WeaveError
27
30
from bzrlib.weavefile import write_weave, read_weave
28
 
from pprint import pformat
29
 
 
 
31
from bzrlib.selftest import TestCase
 
32
from bzrlib.osutils import sha_string
30
33
 
31
34
try:
32
35
    set
46
49
 
47
50
 
48
51
 
49
 
class TestBase(testsweet.TestBase):
 
52
class TestBase(TestCase):
50
53
    def check_read_write(self, k):
51
54
        """Check the weave k can be written & re-read."""
52
55
        from tempfile import TemporaryFile
60
63
            tf.seek(0)
61
64
            self.log('serialized weave:')
62
65
            self.log(tf.read())
 
66
 
 
67
            self.log('')
 
68
            self.log('parents: %s' % (k._parents == k2._parents))
 
69
            self.log('         %r' % k._parents)
 
70
            self.log('         %r' % k2._parents)
 
71
            self.log('')
 
72
 
 
73
            
63
74
            self.fail('read/write check failed')
64
75
        
65
76
        
74
85
    """Store and retrieve a simple text."""
75
86
    def runTest(self):
76
87
        k = Weave()
77
 
        idx = k.add([], TEXT_0)
 
88
        idx = k.add('text0', [], TEXT_0)
78
89
        self.assertEqual(k.get(idx), TEXT_0)
79
90
        self.assertEqual(idx, 0)
80
91
 
83
94
class AnnotateOne(TestBase):
84
95
    def runTest(self):
85
96
        k = Weave()
86
 
        k.add([], TEXT_0)
 
97
        k.add('text0', [], TEXT_0)
87
98
        self.assertEqual(k.annotate(0),
88
99
                         [(0, TEXT_0[0])])
89
100
 
92
103
    def runTest(self):
93
104
        k = Weave()
94
105
 
95
 
        idx = k.add([], TEXT_0)
 
106
        idx = k.add('text0', [], TEXT_0)
96
107
        self.assertEqual(idx, 0)
97
108
 
98
 
        idx = k.add([], TEXT_1)
 
109
        idx = k.add('text1', [], TEXT_1)
99
110
        self.assertEqual(idx, 1)
100
111
 
101
112
        self.assertEqual(k.get(0), TEXT_0)
102
113
        self.assertEqual(k.get(1), TEXT_1)
103
114
 
104
 
        k.dump(self.TEST_LOG)
 
115
 
 
116
 
 
117
class AddWithGivenSha(TestBase):
 
118
    def runTest(self):
 
119
        """Add with caller-supplied SHA-1"""
 
120
        k = Weave()
 
121
 
 
122
        t = 'text0'
 
123
        k.add('text0', [], [t], sha1=sha_string(t))
105
124
 
106
125
 
107
126
 
112
131
 
113
132
        self.assertRaises(IndexError,
114
133
                          k.add,
 
134
                          'text0',
115
135
                          [69],
116
136
                          ['new text!'])
117
137
 
118
138
 
 
139
class RepeatedAdd(TestBase):
 
140
    """Add the same version twice; harmless."""
 
141
    def runTest(self):
 
142
        k = Weave()
 
143
        idx = k.add('text0', [], TEXT_0)
 
144
        idx2 = k.add('text0', [], TEXT_0)
 
145
        self.assertEqual(idx, idx2)
 
146
 
 
147
 
 
148
 
 
149
class InvalidRepeatedAdd(TestBase):
 
150
    def runTest(self):
 
151
        k = Weave()
 
152
        idx = k.add('text0', [], TEXT_0)
 
153
        self.assertRaises(WeaveError,
 
154
                          k.add,
 
155
                          'text0',
 
156
                          [],
 
157
                          ['not the same text'])
 
158
        self.assertRaises(WeaveError,
 
159
                          k.add,
 
160
                          'text0',
 
161
                          [12],         # not the right parents
 
162
                          TEXT_0)
 
163
        
 
164
 
 
165
 
119
166
class InsertLines(TestBase):
120
167
    """Store a revision that adds one line to the original.
121
168
 
124
171
    def runTest(self):
125
172
        k = Weave()
126
173
 
127
 
        k.add([], ['line 1'])
128
 
        k.add([0], ['line 1', 'line 2'])
 
174
        k.add('text0', [], ['line 1'])
 
175
        k.add('text1', [0], ['line 1', 'line 2'])
129
176
 
130
177
        self.assertEqual(k.annotate(0),
131
178
                         [(0, 'line 1')])
138
185
                         [(0, 'line 1'),
139
186
                          (1, 'line 2')])
140
187
 
141
 
        k.add([0], ['line 1', 'diverged line'])
 
188
        k.add('text2', [0], ['line 1', 'diverged line'])
142
189
 
143
190
        self.assertEqual(k.annotate(2),
144
191
                         [(0, 'line 1'),
145
192
                          (2, 'diverged line')])
146
193
 
147
194
        text3 = ['line 1', 'middle line', 'line 2']
148
 
        k.add([0, 1],
 
195
        k.add('text3',
 
196
              [0, 1],
149
197
              text3)
150
198
 
151
199
        # self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))
158
206
                          (1, 'line 2')])
159
207
 
160
208
        # now multiple insertions at different places
161
 
        k.add([0, 1, 3],
 
209
        k.add('text4',
 
210
              [0, 1, 3],
162
211
              ['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])
163
212
 
164
213
        self.assertEqual(k.annotate(4), 
180
229
 
181
230
        base_text = ['one', 'two', 'three', 'four']
182
231
 
183
 
        k.add([], base_text)
 
232
        k.add('text0', [], base_text)
184
233
        
185
234
        texts = [['one', 'two', 'three'],
186
235
                 ['two', 'three', 'four'],
188
237
                 ['one', 'two', 'three', 'four'],
189
238
                 ]
190
239
 
 
240
        i = 1
191
241
        for t in texts:
192
 
            ver = k.add([0], t)
 
242
            ver = k.add('text%d' % i,
 
243
                        [0], t)
 
244
            i += 1
193
245
 
194
246
        self.log('final weave:')
195
247
        self.log('k._weave=' + pformat(k._weave))
406
458
    def runTest(self):
407
459
        k = Weave()
408
460
 
409
 
        k.add([], ["line the first",
 
461
        k.add('text0', [], ["line the first",
410
462
                   "line 2",
411
463
                   "line 3",
412
464
                   "fine"])
413
465
 
414
466
        self.assertEqual(len(k.get(0)), 4)
415
467
 
416
 
        k.add([0], ["line the first",
 
468
        k.add('text1', [0], ["line the first",
417
469
                   "fine"])
418
470
 
419
471
        self.assertEqual(k.get(1),
454
506
        self.assertEqual(k.get(0),
455
507
                         ["first line"])
456
508
 
457
 
        k.dump(self.TEST_LOG)
458
 
 
459
509
 
460
510
class DivergedIncludes(TestBase):
461
511
    """Weave with two diverged texts based on version 0.
501
551
        text0 = ['cheddar', 'stilton', 'gruyere']
502
552
        text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']
503
553
        
504
 
        k.add([], text0)
505
 
        k.add([0], text1)
 
554
        k.add('text0', [], text0)
 
555
        k.add('text1', [0], text1)
506
556
 
507
557
        self.log('k._weave=' + pformat(k._weave))
508
558
 
522
572
                 ['header', '', 'line from 1', 'fixup line', 'line from 2'],
523
573
                 ]
524
574
 
525
 
        k.add([], texts[0])
526
 
        k.add([0], texts[1])
527
 
        k.add([0], texts[2])
528
 
        k.add([0, 1, 2], texts[3])
 
575
        k.add('text0', [], texts[0])
 
576
        k.add('text1', [0], texts[1])
 
577
        k.add('text2', [0], texts[2])
 
578
        k.add('merge', [0, 1, 2], texts[3])
529
579
 
530
580
        for i, t in enumerate(texts):
531
581
            self.assertEqual(k.get(i), t)
593
643
                 ['header', 'aaa', 'bbb', 'line from 2', 'more from 2'],
594
644
                 ]
595
645
 
596
 
        k.add([], texts[0])
597
 
        k.add([0], texts[1])
598
 
        k.add([0], texts[2])
 
646
        k.add('text0', [], texts[0])
 
647
        k.add('text1', [0], texts[1])
 
648
        k.add('text2', [0], texts[2])
599
649
 
600
650
        self.log('k._weave=' + pformat(k._weave))
601
651
 
641
691
 
642
692
        k = Weave()
643
693
        parents = set()
 
694
        i = 0
644
695
        for t in texts:
645
 
            ver = k.add(list(parents), t)
 
696
            ver = k.add('text%d' % i,
 
697
                        list(parents), t)
646
698
            parents.add(ver)
 
699
            i += 1
647
700
 
648
701
        self.log("k._weave=" + pformat(k._weave))
649
702
 
663
716
            return x + '\n'
664
717
        
665
718
        w = Weave()
666
 
        w.add([], map(addcrlf, base))
667
 
        w.add([0], map(addcrlf, a))
668
 
        w.add([0], map(addcrlf, b))
 
719
        w.add('text0', [], map(addcrlf, base))
 
720
        w.add('text1', [0], map(addcrlf, a))
 
721
        w.add('text2', [0], map(addcrlf, b))
669
722
 
670
723
        self.log('weave is:')
671
724
        tmpf = StringIO()
752
805
    
753
806
 
754
807
 
755
 
def testweave():
756
 
    import testsweet
757
 
    from unittest import TestSuite, TestLoader
758
 
    import testweave
759
 
 
760
 
    tl = TestLoader()
761
 
    suite = TestSuite()
762
 
    suite.addTest(tl.loadTestsFromModule(testweave))
763
 
    
764
 
    return int(not testsweet.run_suite(suite)) # for shell 0=true
765
 
 
766
 
 
767
808
if __name__ == '__main__':
768
809
    import sys
769
 
    sys.exit(testweave())
 
810
    import unittest
 
811
    sys.exit(unittest.main())
770
812