← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_weave.py

  • Committer: Patch Queue Manager
  • Date: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_weave.py
1
 
#! /usr/bin/python2.4
2
 
 
3
 
# Copyright (C) 2005 by Canonical Ltd
4
 
 
 
1
# Copyright (C) 2005-2009, 2011 Canonical Ltd
 
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
7
5
# the Free Software Foundation; either version 2 of the License, or
8
6
# (at your option) any later version.
9
 
 
 
7
#
10
8
# This program is distributed in the hope that it will be useful,
11
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
11
# GNU General Public License for more details.
14
 
 
 
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
 
20
18
# TODO: tests regarding version names
21
 
# TODO: rbc 20050108 test that join does not leave an inconsistent weave 
 
19
# TODO: rbc 20050108 test that join does not leave an inconsistent weave
22
20
#       if it fails.
23
21
 
24
22
"""test suite for weave algorithm"""
25
23
 
26
24
from pprint import pformat
27
25
 
28
 
import bzrlib.errors as errors
29
 
from bzrlib.weave import Weave, WeaveFormatError, WeaveError, reweave
 
26
from bzrlib import (
 
27
    errors,
 
28
    )
 
29
from bzrlib.osutils import sha_string
 
30
from bzrlib.tests import TestCase, TestCaseInTempDir
 
31
from bzrlib.weave import Weave, WeaveFormatError
30
32
from bzrlib.weavefile import write_weave, read_weave
31
 
from bzrlib.tests import TestCase
32
 
from bzrlib.osutils import sha_string
33
33
 
34
34
 
35
35
# texts for use in testing
39
39
 
40
40
 
41
41
class TestBase(TestCase):
 
42
 
42
43
    def check_read_write(self, k):
43
44
        """Check the weave k can be written & re-read."""
44
45
        from tempfile import TemporaryFile
63
64
 
64
65
class WeaveContains(TestBase):
65
66
    """Weave __contains__ operator"""
 
67
 
66
68
    def runTest(self):
67
 
        k = Weave()
 
69
        k = Weave(get_scope=lambda:None)
68
70
        self.assertFalse('foo' in k)
69
71
        k.add_lines('foo', [], TEXT_1)
70
72
        self.assertTrue('foo' in k)
71
73
 
72
74
 
73
75
class Easy(TestBase):
 
76
 
74
77
    def runTest(self):
75
78
        k = Weave()
76
79
 
77
80
 
78
 
class StoreText(TestBase):
79
 
    """Store and retrieve a simple text."""
80
 
 
81
 
    def test_storing_text(self):
82
 
        k = Weave()
83
 
        idx = k.add_lines('text0', [], TEXT_0)
84
 
        self.assertEqual(k.get_lines(idx), TEXT_0)
85
 
        self.assertEqual(idx, 0)
86
 
 
87
 
 
88
81
class AnnotateOne(TestBase):
 
82
 
89
83
    def runTest(self):
90
84
        k = Weave()
91
85
        k.add_lines('text0', [], TEXT_0)
93
87
                         [('text0', TEXT_0[0])])
94
88
 
95
89
 
96
 
class StoreTwo(TestBase):
97
 
    def runTest(self):
98
 
        k = Weave()
99
 
 
100
 
        idx = k.add_lines('text0', [], TEXT_0)
101
 
        self.assertEqual(idx, 0)
102
 
 
103
 
        idx = k.add_lines('text1', [], TEXT_1)
104
 
        self.assertEqual(idx, 1)
105
 
 
106
 
        self.assertEqual(k.get_lines(0), TEXT_0)
107
 
        self.assertEqual(k.get_lines(1), TEXT_1)
108
 
 
109
 
 
110
 
class GetSha1(TestBase):
111
 
    def test_get_sha1(self):
112
 
        k = Weave()
113
 
        k.add_lines('text0', [], 'text0')
114
 
        self.assertEqual('34dc0e430c642a26c3dd1c2beb7a8b4f4445eb79',
115
 
                         k.get_sha1('text0'))
116
 
        self.assertRaises(errors.RevisionNotPresent,
117
 
                          k.get_sha1, 0)
118
 
        self.assertRaises(errors.RevisionNotPresent,
119
 
                          k.get_sha1, 'text1')
120
 
                        
121
 
 
122
90
class InvalidAdd(TestBase):
123
91
    """Try to use invalid version number during add."""
 
92
 
124
93
    def runTest(self):
125
94
        k = Weave()
126
95
 
133
102
 
134
103
class RepeatedAdd(TestBase):
135
104
    """Add the same version twice; harmless."""
136
 
    def runTest(self):
 
105
 
 
106
    def test_duplicate_add(self):
137
107
        k = Weave()
138
108
        idx = k.add_lines('text0', [], TEXT_0)
139
109
        idx2 = k.add_lines('text0', [], TEXT_0)
141
111
 
142
112
 
143
113
class InvalidRepeatedAdd(TestBase):
 
114
 
144
115
    def runTest(self):
145
116
        k = Weave()
146
117
        k.add_lines('basis', [], TEXT_0)
155
126
                          'text0',
156
127
                          ['basis'],         # not the right parents
157
128
                          TEXT_0)
158
 
        
 
129
 
159
130
 
160
131
class InsertLines(TestBase):
161
132
    """Store a revision that adds one line to the original.
204
175
              ['text0', 'text1', 'text3'],
205
176
              ['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])
206
177
 
207
 
        self.assertEqual(k.annotate('text4'), 
 
178
        self.assertEqual(k.annotate('text4'),
208
179
                         [('text0', 'line 1'),
209
180
                          ('text4', 'aaa'),
210
181
                          ('text3', 'middle line'),
223
194
        base_text = ['one', 'two', 'three', 'four']
224
195
 
225
196
        k.add_lines('text0', [], base_text)
226
 
        
 
197
 
227
198
        texts = [['one', 'two', 'three'],
228
199
                 ['two', 'three', 'four'],
229
200
                 ['one', 'four'],
260
231
                ]
261
232
        ################################### SKIPPED
262
233
        # Weave.get doesn't trap this anymore
263
 
        return 
 
234
        return
264
235
 
265
236
        self.assertRaises(WeaveFormatError,
266
237
                          k.get_lines,
267
 
                          0)        
 
238
                          0)
268
239
 
269
240
 
270
241
class CannedDelete(TestBase):
312
283
                'line to be deleted',
313
284
                (']', 1),
314
285
                ('{', 1),
315
 
                'replacement line',                
 
286
                'replacement line',
316
287
                ('}', 1),
317
288
                'last line',
318
289
                ('}', 0),
355
326
 
356
327
        ################################### SKIPPED
357
328
        # Weave.get doesn't trap this anymore
358
 
        return 
 
329
        return
359
330
 
360
331
 
361
332
        self.assertRaises(WeaveFormatError,
433
404
                          '  added in version 1',
434
405
                          '  also from v1',
435
406
                          '}'])
436
 
                       
 
407
 
437
408
        self.assertEqual(k.get_lines(2),
438
409
                         ['foo {',
439
410
                          '  added in v2',
445
416
                          '  added in v2',
446
417
                          '  also from v1',
447
418
                          '}'])
448
 
                         
 
419
 
449
420
 
450
421
class DeleteLines2(TestBase):
451
422
    """Test recording revisions that delete lines.
527
498
                ('}', 1),
528
499
                ('{', 2),
529
500
                "alternative second line",
530
 
                ('}', 2),                
 
501
                ('}', 2),
531
502
                ]
532
503
 
533
504
        k._sha1s = [sha_string('first line')
555
526
 
556
527
        text0 = ['cheddar', 'stilton', 'gruyere']
557
528
        text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']
558
 
        
 
529
 
559
530
        k.add_lines('text0', [], text0)
560
531
        k.add_lines('text1', ['text0'], text1)
561
532
 
567
538
 
568
539
class Merge(TestBase):
569
540
    """Storage of versions that merge diverged parents"""
 
541
 
570
542
    def runTest(self):
571
543
        k = Weave()
572
544
 
643
615
            A Jug of Wine, a Loaf of Bread, -- and Thou
644
616
            Beside me singing in the Wilderness --
645
617
            Oh, Wilderness were Paradise enow!""",
646
 
            
 
618
 
647
619
            """A Book of Verses underneath the Bough,
648
620
            A Jug of Wine, a Loaf of Bread, -- and Thou
649
621
            Beside me singing in the Wilderness --
683
655
 
684
656
 
685
657
class JoinWeavesTests(TestBase):
 
658
 
686
659
    def setUp(self):
687
660
        super(JoinWeavesTests, self).setUp()
688
661
        self.weave1 = Weave()
691
664
        self.weave1.add_lines('v1', [], self.lines1)
692
665
        self.weave1.add_lines('v2', ['v1'], ['hello\n', 'world\n'])
693
666
        self.weave1.add_lines('v3', ['v2'], self.lines3)
694
 
        
695
 
    def test_join_empty(self):
696
 
        """Join two empty weaves."""
697
 
        eq = self.assertEqual
698
 
        w1 = Weave()
699
 
        w2 = Weave()
700
 
        w1.join(w2)
701
 
        eq(len(w1), 0)
702
 
        
703
 
    def test_join_empty_to_nonempty(self):
704
 
        """Join empty weave onto nonempty."""
705
 
        self.weave1.join(Weave())
706
 
        self.assertEqual(len(self.weave1), 3)
707
 
 
708
 
    def test_join_unrelated(self):
709
 
        """Join two weaves with no history in common."""
710
 
        wb = Weave()
711
 
        wb.add_lines('b1', [], ['line from b\n'])
712
 
        w1 = self.weave1
713
 
        w1.join(wb)
714
 
        eq = self.assertEqual
715
 
        eq(len(w1), 4)
716
 
        eq(sorted(w1.versions()),
717
 
           ['b1', 'v1', 'v2', 'v3'])
718
 
 
719
 
    def test_join_related(self):
720
 
        wa = self.weave1.copy()
721
 
        wb = self.weave1.copy()
722
 
        wa.add_lines('a1', ['v3'], ['hello\n', 'sweet\n', 'world\n'])
723
 
        wb.add_lines('b1', ['v3'], ['hello\n', 'pale blue\n', 'world\n'])
724
 
        eq = self.assertEquals
725
 
        eq(len(wa), 4)
726
 
        eq(len(wb), 4)
727
 
        wa.join(wb)
728
 
        eq(len(wa), 5)
729
 
        eq(wa.get_lines('b1'),
730
 
           ['hello\n', 'pale blue\n', 'world\n'])
731
 
 
732
 
    def test_join_parent_disagreement(self):
733
 
        #join reconciles differening parents into a union.
734
 
        wa = Weave()
735
 
        wb = Weave()
736
 
        wa.add_lines('v1', [], ['hello\n'])
737
 
        wb.add_lines('v0', [], [])
738
 
        wb.add_lines('v1', ['v0'], ['hello\n'])
739
 
        wa.join(wb)
740
 
        self.assertEqual(['v0'], wa.get_parents('v1'))
741
 
 
742
 
    def test_join_text_disagreement(self):
743
 
        """Cannot join weaves with different texts for a version."""
744
 
        wa = Weave()
745
 
        wb = Weave()
746
 
        wa.add_lines('v1', [], ['hello\n'])
747
 
        wb.add_lines('v1', [], ['not\n', 'hello\n'])
748
 
        self.assertRaises(WeaveError,
749
 
                          wa.join, wb)
750
 
 
751
 
    def test_join_unordered(self):
752
 
        """Join weaves where indexes differ.
753
 
        
754
 
        The source weave contains a different version at index 0."""
755
 
        wa = self.weave1.copy()
756
 
        wb = Weave()
757
 
        wb.add_lines('x1', [], ['line from x1\n'])
758
 
        wb.add_lines('v1', [], ['hello\n'])
759
 
        wb.add_lines('v2', ['v1'], ['hello\n', 'world\n'])
760
 
        wa.join(wb)
761
 
        eq = self.assertEquals
762
 
        eq(sorted(wa.versions()), ['v1', 'v2', 'v3', 'x1',])
763
 
        eq(wa.get_text('x1'), 'line from x1\n')
764
667
 
765
668
    def test_written_detection(self):
766
669
        # Test detection of weave file corruption.
811
714
        self.assertRaises(errors.WeaveInvalidChecksum, w.check)
812
715
 
813
716
 
 
717
class TestWeave(TestCase):
 
718
 
 
719
    def test_allow_reserved_false(self):
 
720
        w = Weave('name', allow_reserved=False)
 
721
        # Add lines is checked at the WeaveFile level, not at the Weave level
 
722
        w.add_lines('name:', [], TEXT_1)
 
723
        # But get_lines is checked at this level
 
724
        self.assertRaises(errors.ReservedId, w.get_lines, 'name:')
 
725
 
 
726
    def test_allow_reserved_true(self):
 
727
        w = Weave('name', allow_reserved=True)
 
728
        w.add_lines('name:', [], TEXT_1)
 
729
        self.assertEqual(TEXT_1, w.get_lines('name:'))
 
730
 
 
731
 
814
732
class InstrumentedWeave(Weave):
815
733
    """Keep track of how many times functions are called."""
816
 
    
 
734
 
817
735
    def __init__(self, weave_name=None):
818
736
        self._extract_count = 0
819
737
        Weave.__init__(self, weave_name=weave_name)
823
741
        return Weave._extract(self, versions)
824
742
 
825
743
 
826
 
class JoinOptimization(TestCase):
827
 
    """Test that Weave.join() doesn't extract all texts, only what must be done."""
828
 
 
829
 
    def test_join(self):
830
 
        w1 = InstrumentedWeave()
831
 
        w2 = InstrumentedWeave()
832
 
 
833
 
        txt0 = ['a\n']
834
 
        txt1 = ['a\n', 'b\n']
835
 
        txt2 = ['a\n', 'c\n']
836
 
        txt3 = ['a\n', 'b\n', 'c\n']
837
 
 
838
 
        w1.add_lines('txt0', [], txt0) # extract 1a
839
 
        w2.add_lines('txt0', [], txt0) # extract 1b
840
 
        w1.add_lines('txt1', ['txt0'], txt1)# extract 2a
841
 
        w2.add_lines('txt2', ['txt0'], txt2)# extract 2b
842
 
        w1.join(w2) # extract 3a to add txt2 
843
 
        w2.join(w1) # extract 3b to add txt1 
844
 
 
845
 
        w1.add_lines('txt3', ['txt1', 'txt2'], txt3) # extract 4a 
846
 
        w2.add_lines('txt3', ['txt2', 'txt1'], txt3) # extract 4b
847
 
        # These secretly have inverted parents
848
 
 
849
 
        # This should not have to do any extractions
850
 
        w1.join(w2) # NO extract, texts already present with same parents
851
 
        w2.join(w1) # NO extract, texts already present with same parents
852
 
 
853
 
        self.assertEqual(4, w1._extract_count)
854
 
        self.assertEqual(4, w2._extract_count)
855
 
 
856
 
    def test_double_parent(self):
857
 
        # It should not be considered illegal to add
858
 
        # a revision with the same parent twice
859
 
        w1 = InstrumentedWeave()
860
 
        w2 = InstrumentedWeave()
861
 
 
862
 
        txt0 = ['a\n']
863
 
        txt1 = ['a\n', 'b\n']
864
 
        txt2 = ['a\n', 'c\n']
865
 
        txt3 = ['a\n', 'b\n', 'c\n']
866
 
 
867
 
        w1.add_lines('txt0', [], txt0)
868
 
        w2.add_lines('txt0', [], txt0)
869
 
        w1.add_lines('txt1', ['txt0'], txt1)
870
 
        w2.add_lines('txt1', ['txt0', 'txt0'], txt1)
871
 
        # Same text, effectively the same, because the
872
 
        # parent is only repeated
873
 
        w1.join(w2) # extract 3a to add txt2 
874
 
        w2.join(w1) # extract 3b to add txt1 
875
 
 
876
 
 
877
744
class TestNeedsReweave(TestCase):
878
745
    """Internal corner cases for when reweave is needed."""
879
746
 
890
757
        self.assertFalse(w1._compatible_parents(set(), set([1])))
891
758
        self.assertFalse(w1._compatible_parents(my_parents, set([1, 2, 3, 4])))
892
759
        self.assertFalse(w1._compatible_parents(my_parents, set([4])))
 
760
 
 
761
 
 
762
class TestWeaveFile(TestCaseInTempDir):
 
763
 
 
764
    def test_empty_file(self):
 
765
        f = open('empty.weave', 'wb+')
 
766
        try:
 
767
            self.assertRaises(errors.WeaveFormatError,
 
768
                              read_weave, f)
 
769
        finally:
 
770
            f.close()