← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to tests/test__groupcompress_pyx.py

  • Committer: John Arbash Meinel
  • Date: 2009-03-02 19:36:29 UTC
  • mto: (0.17.31 trunk)
  • mto: This revision was merged to the branch mainline in revision 4280.
  • Revision ID: john@arbash-meinel.com-20090302193629-51hqsvh1rhh71gku
We now start to make use of the ability to extend the delta index
with new sources. Next step is to understand the delta encoding, so as to
avoid linking up with lines in the deltas.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test__groupcompress_pyx.py
60
60
at the end of the file
61
61
"""
62
62
 
 
63
_first_text = """\
 
64
a bit of text, that
 
65
does not have much in
 
66
common with the next text
 
67
"""
 
68
 
 
69
_second_text = """\
 
70
some more bits of text
 
71
which does have a little bit in
 
72
common with the previous text
 
73
"""
 
74
 
 
75
 
 
76
_third_text = """\
 
77
a bit of text, that
 
78
has some in common with the previous text
 
79
and not much in
 
80
common with the next text
 
81
"""
 
82
 
63
83
 
64
84
class Test_GroupCompress(tests.TestCase):
65
85
    """Direct tests for the compiled extension."""
141
161
 
142
162
    def test_delta_against_multiple_sources(self):
143
163
        di = self._gc_module.DeltaIndex()
144
 
        first_text = ('a bit of text, that\n'
145
 
                      'does not have much in\n'
146
 
                      'common with the next text\n'
147
 
                     )
148
 
        di.add_source(first_text)
 
164
        di.add_source(_first_text, 0)
149
165
        self.assertEqual(1, di._num_indexes)
150
166
        self.assertEqual(1024, di._max_num_indexes)
151
 
        self.assertEqual(len(first_text), di._source_offset)
152
 
        second_text = ('some more bits of text\n'
153
 
                       'which does have a little bit in\n'
154
 
                       'common with the previous text\n'
155
 
                      )
156
 
        di.add_source(second_text)
 
167
        self.assertEqual(len(_first_text), di._source_offset)
 
168
        di.add_source(_second_text, 0)
157
169
        self.assertEqual(2, di._num_indexes)
158
170
        self.assertEqual(1024, di._max_num_indexes)
159
 
        self.assertEqual(len(first_text) + len(second_text), di._source_offset)
160
 
        third_text = ('a bit of text, that\n'
161
 
                      'has some in common with the previous text\n'
162
 
                      'and not much in\n'
163
 
                      'common with the next text\n'
164
 
                     )
165
 
        delta = di.make_delta(third_text)
166
 
        result = self._gc_module.apply_delta(first_text + second_text, delta)
167
 
        self.assertEqualDiff(third_text, result)
 
171
        self.assertEqual(len(_first_text) + len(_second_text), di._source_offset)
 
172
        delta = di.make_delta(_third_text)
 
173
        result = self._gc_module.apply_delta(_first_text + _second_text, delta)
 
174
        self.assertEqualDiff(_third_text, result)
168
175
        self.assertEqual('\x99\x01h\x90\x14\x0chas some in '
169
176
                         '\x91{\x1e\x07and not\x91!#', delta)
170
177
 
 
178
    def test_delta_with_offsets(self):
 
179
        di = self._gc_module.DeltaIndex()
 
180
        di.add_source(_first_text, 5)
 
181
        self.assertEqual(1, di._num_indexes)
 
182
        self.assertEqual(1024, di._max_num_indexes)
 
183
        self.assertEqual(len(_first_text) + 5, di._source_offset)
 
184
        di.add_source(_second_text, 10)
 
185
        self.assertEqual(2, di._num_indexes)
 
186
        self.assertEqual(1024, di._max_num_indexes)
 
187
        self.assertEqual(len(_first_text) + len(_second_text) + 15,
 
188
                         di._source_offset)
 
189
        delta = di.make_delta(_third_text)
 
190
        self.assertIsNot(None, delta)
 
191
        result = self._gc_module.apply_delta(
 
192
            '12345' + _first_text + '1234567890' + _second_text, delta)
 
193
        self.assertIsNot(None, result)
 
194
        self.assertEqualDiff(_third_text, result)
 
195
        self.assertEqual('\xa8\x01h\x91\x05\x14\x0chas some in '
 
196
                         '\x91\x8a\x1e\x07and not\x91&#', delta)