← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/test_weave.py

[merge] robertc's integration, updated tests to check for retcode=3

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/test_weave.py
18
18
 
19
19
 
20
20
# TODO: tests regarding version names
21
 
 
22
 
 
 
21
# TODO: rbc 20050108 test that join does not leave an inconsistent weave 
 
22
#       if it fails.
23
23
 
24
24
"""test suite for weave algorithm"""
25
25
 
 
26
from pprint import pformat
26
27
 
27
 
import testsweet
28
 
from bzrlib.weave import Weave, WeaveFormatError
 
28
import bzrlib.errors as errors
 
29
from bzrlib.weave import Weave, WeaveFormatError, WeaveError, reweave
29
30
from bzrlib.weavefile import write_weave, read_weave
30
 
from pprint import pformat
31
 
 
32
 
 
33
 
try:
34
 
    set
35
 
    frozenset
36
 
except NameError:
37
 
    from sets import Set, ImmutableSet
38
 
    set = Set
39
 
    frozenset = ImmutableSet
40
 
    del Set, ImmutableSet
41
 
 
 
31
from bzrlib.selftest import TestCase
 
32
from bzrlib.osutils import sha_string
42
33
 
43
34
 
44
35
# texts for use in testing
48
39
 
49
40
 
50
41
 
51
 
class TestBase(testsweet.TestBase):
 
42
class TestBase(TestCase):
52
43
    def check_read_write(self, k):
53
44
        """Check the weave k can be written & re-read."""
54
45
        from tempfile import TemporaryFile
68
59
            self.log('         %r' % k._parents)
69
60
            self.log('         %r' % k2._parents)
70
61
            self.log('')
71
 
 
72
 
            
73
62
            self.fail('read/write check failed')
74
 
        
75
 
        
 
63
 
 
64
 
 
65
class WeaveContains(TestBase):
 
66
    """Weave __contains__ operator"""
 
67
    def runTest(self):
 
68
        k = Weave()
 
69
        self.assertFalse('foo' in k)
 
70
        k.add('foo', [], TEXT_1)
 
71
        self.assertTrue('foo' in k)
76
72
 
77
73
 
78
74
class Easy(TestBase):
111
107
        self.assertEqual(k.get(0), TEXT_0)
112
108
        self.assertEqual(k.get(1), TEXT_1)
113
109
 
114
 
        k.dump(self.TEST_LOG)
 
110
 
 
111
 
 
112
class AddWithGivenSha(TestBase):
 
113
    def runTest(self):
 
114
        """Add with caller-supplied SHA-1"""
 
115
        k = Weave()
 
116
 
 
117
        t = 'text0'
 
118
        k.add('text0', [], [t], sha1=sha_string(t))
115
119
 
116
120
 
117
121
 
127
131
                          ['new text!'])
128
132
 
129
133
 
 
134
class RepeatedAdd(TestBase):
 
135
    """Add the same version twice; harmless."""
 
136
    def runTest(self):
 
137
        k = Weave()
 
138
        idx = k.add('text0', [], TEXT_0)
 
139
        idx2 = k.add('text0', [], TEXT_0)
 
140
        self.assertEqual(idx, idx2)
 
141
 
 
142
 
 
143
 
 
144
class InvalidRepeatedAdd(TestBase):
 
145
    def runTest(self):
 
146
        k = Weave()
 
147
        idx = k.add('text0', [], TEXT_0)
 
148
        self.assertRaises(WeaveError,
 
149
                          k.add,
 
150
                          'text0',
 
151
                          [],
 
152
                          ['not the same text'])
 
153
        self.assertRaises(WeaveError,
 
154
                          k.add,
 
155
                          'text0',
 
156
                          [12],         # not the right parents
 
157
                          TEXT_0)
 
158
        
 
159
 
 
160
 
130
161
class InsertLines(TestBase):
131
162
    """Store a revision that adds one line to the original.
132
163
 
470
501
        self.assertEqual(k.get(0),
471
502
                         ["first line"])
472
503
 
473
 
        k.dump(self.TEST_LOG)
474
 
 
475
504
 
476
505
class DivergedIncludes(TestBase):
477
506
    """Weave with two diverged texts based on version 0.
729
758
        self.doMerge(['aaa', 'bbb'],
730
759
                     ['aaa', 'xxx', 'yyy', 'bbb'],
731
760
                     ['aaa', 'xxx', 'bbb'],
732
 
                     ['aaa', '<<<<', 'xxx', 'yyy', '====', 'xxx', '>>>>', 'bbb'])
 
761
                     ['aaa', '<<<<<<<', 'xxx', 'yyy', '=======', 'xxx', 
 
762
                      '>>>>>>>', 'bbb'])
733
763
 
734
764
        # really it ought to reduce this to 
735
765
        # ['aaa', 'xxx', 'yyy', 'bbb']
739
769
        self.doMerge(['aaa'],
740
770
                     ['xxx'],
741
771
                     ['yyy', 'zzz'],
742
 
                     ['<<<<', 'xxx', '====', 'yyy', 'zzz', '>>>>'])
 
772
                     ['<<<<<<<', 'xxx', '=======', 'yyy', 'zzz', 
 
773
                      '>>>>>>>'])
743
774
 
744
775
    def testNonClashInsert(self):
745
776
        self.doMerge(['aaa'],
746
777
                     ['xxx', 'aaa'],
747
778
                     ['yyy', 'zzz'],
748
 
                     ['<<<<', 'xxx', 'aaa', '====', 'yyy', 'zzz', '>>>>'])
 
779
                     ['<<<<<<<', 'xxx', 'aaa', '=======', 'yyy', 'zzz', 
 
780
                      '>>>>>>>'])
749
781
 
750
782
        self.doMerge(['aaa'],
751
783
                     ['aaa'],
767
799
        self.doMerge(['aaa', 'bbb', 'ccc'],
768
800
                     ['aaa', 'ddd', 'ccc'],
769
801
                     ['aaa', 'ccc'],
770
 
                     ['<<<<', 'aaa', '====', '>>>>', 'ccc'])
771
 
    
772
 
 
773
 
 
774
 
def testweave():
775
 
    import testsweet
776
 
    from unittest import TestSuite, TestLoader
777
 
    import testweave
778
 
 
779
 
    tl = TestLoader()
780
 
    suite = TestSuite()
781
 
    suite.addTest(tl.loadTestsFromModule(testweave))
782
 
    
783
 
    return int(not testsweet.run_suite(suite)) # for shell 0=true
784
 
 
785
 
 
786
 
if __name__ == '__main__':
787
 
    import sys
788
 
    sys.exit(testweave())
789
 
    
 
802
                     ['<<<<<<<<', 'aaa', '=======', '>>>>>>>', 'ccc'])
 
803
 
 
804
 
 
805
class JoinWeavesTests(TestBase):
 
806
    def setUp(self):
 
807
        super(JoinWeavesTests, self).setUp()
 
808
        self.weave1 = Weave()
 
809
        self.lines1 = ['hello\n']
 
810
        self.lines3 = ['hello\n', 'cruel\n', 'world\n']
 
811
        self.weave1.add('v1', [], self.lines1)
 
812
        self.weave1.add('v2', [0], ['hello\n', 'world\n'])
 
813
        self.weave1.add('v3', [1], self.lines3)
 
814
        
 
815
    def test_join_empty(self):
 
816
        """Join two empty weaves."""
 
817
        eq = self.assertEqual
 
818
        w1 = Weave()
 
819
        w2 = Weave()
 
820
        w1.join(w2)
 
821
        eq(w1.numversions(), 0)
 
822
        
 
823
    def test_join_empty_to_nonempty(self):
 
824
        """Join empty weave onto nonempty."""
 
825
        self.weave1.join(Weave())
 
826
        self.assertEqual(len(self.weave1), 3)
 
827
 
 
828
    def test_join_unrelated(self):
 
829
        """Join two weaves with no history in common."""
 
830
        wb = Weave()
 
831
        wb.add('b1', [], ['line from b\n'])
 
832
        w1 = self.weave1
 
833
        w1.join(wb)
 
834
        eq = self.assertEqual
 
835
        eq(len(w1), 4)
 
836
        eq(sorted(list(w1.iter_names())),
 
837
           ['b1', 'v1', 'v2', 'v3'])
 
838
 
 
839
    def test_join_related(self):
 
840
        wa = self.weave1.copy()
 
841
        wb = self.weave1.copy()
 
842
        wa.add('a1', ['v3'], ['hello\n', 'sweet\n', 'world\n'])
 
843
        wb.add('b1', ['v3'], ['hello\n', 'pale blue\n', 'world\n'])
 
844
        eq = self.assertEquals
 
845
        eq(len(wa), 4)
 
846
        eq(len(wb), 4)
 
847
        wa.join(wb)
 
848
        eq(len(wa), 5)
 
849
        eq(wa.get_lines('b1'),
 
850
           ['hello\n', 'pale blue\n', 'world\n'])
 
851
 
 
852
    def test_join_parent_disagreement(self):
 
853
        """Cannot join weaves with different parents for a version."""
 
854
        wa = Weave()
 
855
        wb = Weave()
 
856
        wa.add('v1', [], ['hello\n'])
 
857
        wb.add('v0', [], [])
 
858
        wb.add('v1', ['v0'], ['hello\n'])
 
859
        self.assertRaises(WeaveError,
 
860
                          wa.join, wb)
 
861
 
 
862
    def test_join_text_disagreement(self):
 
863
        """Cannot join weaves with different texts for a version."""
 
864
        wa = Weave()
 
865
        wb = Weave()
 
866
        wa.add('v1', [], ['hello\n'])
 
867
        wb.add('v1', [], ['not\n', 'hello\n'])
 
868
        self.assertRaises(WeaveError,
 
869
                          wa.join, wb)
 
870
 
 
871
    def test_join_unordered(self):
 
872
        """Join weaves where indexes differ.
 
873
        
 
874
        The source weave contains a different version at index 0."""
 
875
        wa = self.weave1.copy()
 
876
        wb = Weave()
 
877
        wb.add('x1', [], ['line from x1\n'])
 
878
        wb.add('v1', [], ['hello\n'])
 
879
        wb.add('v2', ['v1'], ['hello\n', 'world\n'])
 
880
        wa.join(wb)
 
881
        eq = self.assertEquals
 
882
        eq(sorted(wa.iter_names()), ['v1', 'v2', 'v3', 'x1',])
 
883
        eq(wa.get_text('x1'), 'line from x1\n')