/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test__btree_serializer.py

  • Committer: Jelmer Vernooij
  • Date: 2020-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test__btree_serializer.py
29
29
 
30
30
    _test_needs_features = [compiled_btreeparser_feature]
31
31
 
32
 
    def setUp(self):
33
 
        super(TestBtreeSerializer, self).setUp()
34
 
        self.module = compiled_btreeparser_feature.module
 
32
    @property
 
33
    def module(self):
 
34
        return compiled_btreeparser_feature.module
35
35
 
36
36
 
37
37
class TestHexAndUnhex(TestBtreeSerializer):
45
45
        mod_unhex = self.module._py_unhexlify(as_hex)
46
46
        if ba_unhex != mod_unhex:
47
47
            if mod_unhex is None:
48
 
                mod_hex = '<None>'
 
48
                mod_hex = b'<None>'
49
49
            else:
50
50
                mod_hex = binascii.hexlify(mod_unhex)
51
51
            self.fail('_py_unhexlify returned a different answer'
52
 
                      ' from binascii:\n    %s\n != %s'
 
52
                      ' from binascii:\n    %r\n != %r'
53
53
                      % (binascii.hexlify(ba_unhex), mod_hex))
54
54
 
55
55
    def assertFailUnhexlify(self, as_hex):
57
57
        self.assertIs(None, self.module._py_unhexlify(as_hex))
58
58
 
59
59
    def test_to_hex(self):
60
 
        raw_bytes = ''.join(map(chr, range(256)))
 
60
        raw_bytes = bytes(range(256))
61
61
        for i in range(0, 240, 20):
62
 
            self.assertHexlify(raw_bytes[i:i+20])
63
 
        self.assertHexlify(raw_bytes[240:]+raw_bytes[0:4])
 
62
            self.assertHexlify(raw_bytes[i:i + 20])
 
63
        self.assertHexlify(raw_bytes[240:] + raw_bytes[0:4])
64
64
 
65
65
    def test_from_hex(self):
66
 
        self.assertUnhexlify('0123456789abcdef0123456789abcdef01234567')
67
 
        self.assertUnhexlify('123456789abcdef0123456789abcdef012345678')
68
 
        self.assertUnhexlify('0123456789ABCDEF0123456789ABCDEF01234567')
69
 
        self.assertUnhexlify('123456789ABCDEF0123456789ABCDEF012345678')
70
 
        hex_chars = binascii.hexlify(''.join(map(chr, range(256))))
 
66
        self.assertUnhexlify(b'0123456789abcdef0123456789abcdef01234567')
 
67
        self.assertUnhexlify(b'123456789abcdef0123456789abcdef012345678')
 
68
        self.assertUnhexlify(b'0123456789ABCDEF0123456789ABCDEF01234567')
 
69
        self.assertUnhexlify(b'123456789ABCDEF0123456789ABCDEF012345678')
 
70
        hex_chars = binascii.hexlify(bytes(range(256)))
71
71
        for i in range(0, 480, 40):
72
 
            self.assertUnhexlify(hex_chars[i:i+40])
73
 
        self.assertUnhexlify(hex_chars[480:]+hex_chars[0:8])
 
72
            self.assertUnhexlify(hex_chars[i:i + 40])
 
73
        self.assertUnhexlify(hex_chars[480:] + hex_chars[0:8])
74
74
 
75
75
    def test_from_invalid_hex(self):
76
 
        self.assertFailUnhexlify('123456789012345678901234567890123456789X')
77
 
        self.assertFailUnhexlify('12345678901234567890123456789012345678X9')
78
 
 
79
 
 
80
 
_hex_form = '123456789012345678901234567890abcdefabcd'
 
76
        self.assertFailUnhexlify(b'123456789012345678901234567890123456789X')
 
77
        self.assertFailUnhexlify(b'12345678901234567890123456789012345678X9')
 
78
 
 
79
    def test_bad_argument(self):
 
80
        self.assertRaises(ValueError, self.module._py_unhexlify, u'1a')
 
81
        self.assertRaises(ValueError, self.module._py_unhexlify, b'1b')
 
82
 
 
83
 
 
84
_hex_form = b'123456789012345678901234567890abcdefabcd'
 
85
 
81
86
 
82
87
class Test_KeyToSha1(TestBtreeSerializer):
83
88
 
95
100
                      % (actual_sha1, expected))
96
101
 
97
102
    def test_simple(self):
98
 
        self.assertKeyToSha1(_hex_form, ('sha1:' + _hex_form,))
 
103
        self.assertKeyToSha1(_hex_form, (b'sha1:' + _hex_form,))
99
104
 
100
105
    def test_invalid_not_tuple(self):
101
106
        self.assertKeyToSha1(None, _hex_form)
102
 
        self.assertKeyToSha1(None, 'sha1:' + _hex_form)
 
107
        self.assertKeyToSha1(None, b'sha1:' + _hex_form)
103
108
 
104
109
    def test_invalid_empty(self):
105
110
        self.assertKeyToSha1(None, ())
110
115
 
111
116
    def test_invalid_not_sha1(self):
112
117
        self.assertKeyToSha1(None, (_hex_form,))
113
 
        self.assertKeyToSha1(None, ('sha2:' + _hex_form,))
 
118
        self.assertKeyToSha1(None, (b'sha2:' + _hex_form,))
114
119
 
115
120
    def test_invalid_not_hex(self):
116
121
        self.assertKeyToSha1(None,
117
 
            ('sha1:abcdefghijklmnopqrstuvwxyz12345678901234',))
 
122
                             (b'sha1:abcdefghijklmnopqrstuvwxyz12345678901234',))
118
123
 
119
124
 
120
125
class Test_Sha1ToKey(TestBtreeSerializer):
122
127
    def assertSha1ToKey(self, hex_sha1):
123
128
        bin_sha1 = binascii.unhexlify(hex_sha1)
124
129
        key = self.module._py_sha1_to_key(bin_sha1)
125
 
        self.assertEqual(('sha1:' + hex_sha1,), key)
 
130
        self.assertEqual((b'sha1:' + hex_sha1,), key)
126
131
 
127
132
    def test_simple(self):
128
133
        self.assertSha1ToKey(_hex_form)
129
134
 
130
135
 
131
 
_one_key_content = """type=leaf
 
136
_one_key_content = b"""type=leaf
132
137
sha1:123456789012345678901234567890abcdefabcd\x00\x001 2 3 4
133
138
"""
134
139
 
135
 
_large_offsets = """type=leaf
 
140
_large_offsets = b"""type=leaf
136
141
sha1:123456789012345678901234567890abcdefabcd\x00\x0012345678901 1234567890 0 1
137
142
sha1:abcd123456789012345678901234567890abcdef\x00\x002147483648 2147483647 0 1
138
143
sha1:abcdefabcd123456789012345678901234567890\x00\x004294967296 4294967295 4294967294 1
139
144
"""
140
145
 
141
 
_multi_key_content = """type=leaf
 
146
_multi_key_content = b"""type=leaf
142
147
sha1:c80c881d4a26984ddce795f6f71817c9cf4480e7\x00\x000 0 0 0
143
148
sha1:c86f7e437faa5a7fce15d1ddcb9eaeaea377667b\x00\x001 1 1 1
144
149
sha1:c8e240de74fb1ed08fa08d38063f6a6a91462a81\x00\x002 2 2 2
149
154
sha1:cf7a9e24777ec23212c54d7a350bc5bea5477fdb\x00\x007 7 7 7
150
155
"""
151
156
 
152
 
_multi_key_same_offset = """type=leaf
 
157
_multi_key_same_offset = b"""type=leaf
153
158
sha1:080c881d4a26984ddce795f6f71817c9cf4480e7\x00\x000 0 0 0
154
159
sha1:c86f7e437faa5a7fce15d1ddcb9eaeaea377667b\x00\x001 1 1 1
155
160
sha1:cd0c9035898dd52fc65c41454cec9c4d2611bfb3\x00\x002 2 2 2
160
165
sha1:ce93b4e3c464ffd51732fbd6ded717e9efda28aa\x00\x007 7 7 7
161
166
"""
162
167
 
163
 
_common_32_bits = """type=leaf
 
168
_common_32_bits = b"""type=leaf
164
169
sha1:123456784a26984ddce795f6f71817c9cf4480e7\x00\x000 0 0 0
165
170
sha1:1234567874fb1ed08fa08d38063f6a6a91462a81\x00\x001 1 1 1
166
171
sha1:12345678777ec23212c54d7a350bc5bea5477fdb\x00\x002 2 2 2
174
179
 
175
180
class TestGCCKHSHA1LeafNode(TestBtreeSerializer):
176
181
 
177
 
    def assertInvalid(self, bytes):
 
182
    def assertInvalid(self, data):
178
183
        """Ensure that we get a proper error when trying to parse invalid bytes.
179
184
 
180
185
        (mostly this is testing that bad input doesn't cause us to segfault)
181
186
        """
182
 
        self.assertRaises((ValueError, TypeError), 
183
 
                          self.module._parse_into_chk, bytes, 1, 0)
 
187
        self.assertRaises(
 
188
            (ValueError, TypeError), self.module._parse_into_chk, data, 1, 0)
184
189
 
185
 
    def test_non_str(self):
 
190
    def test_non_bytes(self):
186
191
        self.assertInvalid(u'type=leaf\n')
187
192
 
188
193
    def test_not_leaf(self):
189
 
        self.assertInvalid('type=internal\n')
 
194
        self.assertInvalid(b'type=internal\n')
190
195
 
191
196
    def test_empty_leaf(self):
192
 
        leaf = self.module._parse_into_chk('type=leaf\n', 1, 0)
 
197
        leaf = self.module._parse_into_chk(b'type=leaf\n', 1, 0)
193
198
        self.assertEqual(0, len(leaf))
194
199
        self.assertEqual([], leaf.all_items())
195
200
        self.assertEqual([], leaf.all_keys())
199
204
    def test_one_key_leaf(self):
200
205
        leaf = self.module._parse_into_chk(_one_key_content, 1, 0)
201
206
        self.assertEqual(1, len(leaf))
202
 
        sha_key = ('sha1:' + _hex_form,)
 
207
        sha_key = (b'sha1:' + _hex_form,)
203
208
        self.assertEqual([sha_key], leaf.all_keys())
204
 
        self.assertEqual([(sha_key, ('1 2 3 4', ()))], leaf.all_items())
 
209
        self.assertEqual([(sha_key, (b'1 2 3 4', ()))], leaf.all_items())
205
210
        self.assertTrue(sha_key in leaf)
206
211
 
207
212
    def test_large_offsets(self):
208
213
        leaf = self.module._parse_into_chk(_large_offsets, 1, 0)
209
 
        self.assertEqual(['12345678901 1234567890 0 1',
210
 
                          '2147483648 2147483647 0 1',
211
 
                          '4294967296 4294967295 4294967294 1',
212
 
                         ], [x[1][0] for x in leaf.all_items()])
 
214
        self.assertEqual([b'12345678901 1234567890 0 1',
 
215
                          b'2147483648 2147483647 0 1',
 
216
                          b'4294967296 4294967295 4294967294 1',
 
217
                          ], [x[1][0] for x in leaf.all_items()])
213
218
 
214
219
    def test_many_key_leaf(self):
215
220
        leaf = self.module._parse_into_chk(_multi_key_content, 1, 0)
217
222
        all_keys = leaf.all_keys()
218
223
        self.assertEqual(8, len(leaf.all_keys()))
219
224
        for idx, key in enumerate(all_keys):
220
 
            self.assertEqual(str(idx), leaf[key][0].split()[0])
 
225
            self.assertEqual(b'%d' % idx, leaf[key][0].split()[0])
221
226
 
222
227
    def test_common_shift(self):
223
228
        # The keys were deliberately chosen so that the first 5 bits all
235
240
        for idx, val in enumerate(lst):
236
241
            self.assertEqual(idx, offsets[val])
237
242
        for idx, key in enumerate(leaf.all_keys()):
238
 
            self.assertEqual(str(idx), leaf[key][0].split()[0])
 
243
            self.assertEqual(b'%d' % idx, leaf[key][0].split()[0])
239
244
 
240
245
    def test_multi_key_same_offset(self):
241
246
        # there is no common prefix, though there are some common bits
249
254
        for val in lst:
250
255
            self.assertEqual(lst.index(val), offsets[val])
251
256
        for idx, key in enumerate(leaf.all_keys()):
252
 
            self.assertEqual(str(idx), leaf[key][0].split()[0])
 
257
            self.assertEqual(b'%d' % idx, leaf[key][0].split()[0])
253
258
 
254
259
    def test_all_common_prefix(self):
255
260
        # The first 32 bits of all hashes are the same. This is going to be
263
268
        for val in lst:
264
269
            self.assertEqual(lst.index(val), offsets[val])
265
270
        for idx, key in enumerate(leaf.all_keys()):
266
 
            self.assertEqual(str(idx), leaf[key][0].split()[0])
 
271
            self.assertEqual(b'%d' % idx, leaf[key][0].split()[0])
267
272
 
268
273
    def test_many_entries(self):
269
274
        # Again, this is almost impossible, but we should still work
270
275
        # It would be hard to fit more that 120 entries in a 4k page, much less
271
276
        # more than 256 of them. but hey, weird stuff happens sometimes
272
 
        lines = ['type=leaf\n']
 
277
        lines = [b'type=leaf\n']
273
278
        for i in range(500):
274
 
            key_str = 'sha1:%04x%s' % (i, _hex_form[:36])
 
279
            key_str = b'sha1:%04x%s' % (i, _hex_form[:36])
275
280
            key = (key_str,)
276
 
            lines.append('%s\0\0%d %d %d %d\n' % (key_str, i, i, i, i))
277
 
        bytes = ''.join(lines)
278
 
        leaf = self.module._parse_into_chk(bytes, 1, 0)
279
 
        self.assertEqual(24-7, leaf.common_shift)
 
281
            lines.append(b'%s\0\0%d %d %d %d\n' % (key_str, i, i, i, i))
 
282
        data = b''.join(lines)
 
283
        leaf = self.module._parse_into_chk(data, 1, 0)
 
284
        self.assertEqual(24 - 7, leaf.common_shift)
280
285
        offsets = leaf._get_offsets()
281
286
        # This is the interesting bits for each entry
282
287
        lst = [x // 2 for x in range(500)]
283
 
        expected_offsets = [x * 2 for x in range(128)] + [255]*129
 
288
        expected_offsets = [x * 2 for x in range(128)] + [255] * 129
284
289
        self.assertEqual(expected_offsets, offsets)
285
290
        # We truncate because offsets is an unsigned char. So the bisection
286
291
        # will just say 'greater than the last one' for all the rest
290
295
        for val in lst:
291
296
            self.assertEqual(lst.index(val), offsets[val])
292
297
        for idx, key in enumerate(leaf.all_keys()):
293
 
            self.assertEqual(str(idx), leaf[key][0].split()[0])
 
298
            self.assertEqual(b'%d' % idx, leaf[key][0].split()[0])
294
299
 
295
300
    def test__sizeof__(self):
296
301
        # We can't use the exact numbers because of platform variations, etc.
297
302
        # But what we really care about is that it does get bigger with more
298
303
        # content.
299
 
        leaf0 = self.module._parse_into_chk('type=leaf\n', 1, 0)
 
304
        leaf0 = self.module._parse_into_chk(b'type=leaf\n', 1, 0)
300
305
        leaf1 = self.module._parse_into_chk(_one_key_content, 1, 0)
301
306
        leafN = self.module._parse_into_chk(_multi_key_content, 1, 0)
302
307
        sizeof_1 = leaf1.__sizeof__() - leaf0.__sizeof__()