/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__chk_map.py

  • Committer: Jelmer Vernooij
  • Date: 2019-03-04 00:16:27 UTC
  • mfrom: (7293 work)
  • mto: This revision was merged to the branch mainline in revision 7318.
  • Revision ID: jelmer@jelmer.uk-20190304001627-v6u7o6pf97tukhek
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test__chk_map.py
29
29
 
30
30
def load_tests(loader, standard_tests, pattern):
31
31
    suite, _ = tests.permute_tests_for_extension(standard_tests, loader,
32
 
        'breezy.bzr._chk_map_py', 'breezy.bzr._chk_map_pyx')
 
32
                                                 'breezy.bzr._chk_map_py', 'breezy.bzr._chk_map_pyx')
33
33
    return suite
34
34
 
35
35
 
36
36
class TestSearchKeys(tests.TestCase):
37
37
 
38
 
    module = None # Filled in by test parameterization
 
38
    module = None  # Filled in by test parameterization
39
39
 
40
40
    def assertSearchKey16(self, expected, key):
41
41
        self.assertEqual(expected, self.module._search_key_16(key))
53
53
    def test_simple_255(self):
54
54
        self.assertSearchKey255(b'\x8cse!', stuple(b'foo',))
55
55
        self.assertSearchKey255(b'\x8cse!\x00\x8cse!', stuple(b'foo', b'foo'))
56
 
        self.assertSearchKey255(b'\x8cse!\x00v\xff\x8c\xaa', stuple(b'foo', b'bar'))
 
56
        self.assertSearchKey255(
 
57
            b'\x8cse!\x00v\xff\x8c\xaa', stuple(b'foo', b'bar'))
57
58
        # The standard mapping for these would include '\n', so it should be
58
59
        # mapped to '_'
59
60
        self.assertSearchKey255(b'\xfdm\x93_\x00P_\x1bL', stuple(b'<', b'V'))
63
64
        # character, but all other 255 values should be present
64
65
        chars_used = set()
65
66
        for char_in in range(256):
66
 
            search_key = self.module._search_key_255(stuple(int2byte(char_in),))
 
67
            search_key = self.module._search_key_255(
 
68
                stuple(int2byte(char_in),))
67
69
            chars_used.update(map(int2byte, bytearray(search_key)))
68
70
        all_chars = {int2byte(x) for x in range(256)}
69
71
        unused_chars = all_chars.symmetric_difference(chars_used)
76
78
 
77
79
    def assertDeserialiseErrors(self, text):
78
80
        self.assertRaises((ValueError, IndexError),
79
 
            self.module._deserialise_leaf_node, text, b'not-a-real-sha')
 
81
                          self.module._deserialise_leaf_node, text, b'not-a-real-sha')
80
82
 
81
83
    def test_raises_on_non_leaf(self):
82
84
        self.assertDeserialiseErrors(b'')
105
107
            (b"sha1:1234",))
106
108
        self.assertEqual(2, len(node))
107
109
        self.assertEqual([((b"foo bar",), b"baz"), ((b"quux",), b"blarh")],
108
 
            sorted(node.iteritems(None)))
 
110
                         sorted(node.iteritems(None)))
109
111
 
110
112
    def test_deserialise_item_with_null_width_1(self):
111
113
        node = self.module._deserialise_leaf_node(
113
115
            (b"sha1:1234",))
114
116
        self.assertEqual(2, len(node))
115
117
        self.assertEqual([((b"foo",), b"bar\x00baz"), ((b"quux",), b"blarh")],
116
 
            sorted(node.iteritems(None)))
 
118
                         sorted(node.iteritems(None)))
117
119
 
118
120
    def test_deserialise_item_with_null_width_2(self):
119
121
        node = self.module._deserialise_leaf_node(
122
124
            (b"sha1:1234",))
123
125
        self.assertEqual(2, len(node))
124
126
        self.assertEqual([((b"foo", b"1"), b"bar\x00baz"), ((b"quux", b""), b"blarh")],
125
 
            sorted(node.iteritems(None)))
 
127
                         sorted(node.iteritems(None)))
126
128
 
127
129
    def test_iteritems_selected_one_of_two_items(self):
128
130
        node = self.module._deserialise_leaf_node(
130
132
            (b"sha1:1234",))
131
133
        self.assertEqual(2, len(node))
132
134
        self.assertEqual([((b"quux",), b"blarh")],
133
 
            sorted(node.iteritems(None, [(b"quux",), (b"qaz",)])))
 
135
                         sorted(node.iteritems(None, [(b"quux",), (b"qaz",)])))
134
136
 
135
137
    def test_deserialise_item_with_common_prefix(self):
136
138
        node = self.module._deserialise_leaf_node(
138
140
            (b"sha1:1234",))
139
141
        self.assertEqual(2, len(node))
140
142
        self.assertEqual([((b"foo", b"1"), b"bar\x00baz"), ((b"foo", b"2"), b"blarh")],
141
 
            sorted(node.iteritems(None)))
 
143
                         sorted(node.iteritems(None)))
142
144
        self.assertIs(chk_map._unknown, node._search_prefix)
143
145
        self.assertEqual(b'foo\x00', node._common_serialised_prefix)
144
146
 
149
151
        self.assertEqual(2, len(node))
150
152
        self.assertEqual([((b"foo", b"1"), b"bar\nbaz"),
151
153
                          ((b"foo", b"2"), b"blarh\n"),
152
 
                         ], sorted(node.iteritems(None)))
 
154
                          ], sorted(node.iteritems(None)))
153
155
        self.assertIs(chk_map._unknown, node._search_prefix)
154
156
        self.assertEqual(b'foo\x00', node._common_serialised_prefix)
155
157
 
173
175
 
174
176
    def assertDeserialiseErrors(self, text):
175
177
        self.assertRaises((ValueError, IndexError),
176
 
            self.module._deserialise_internal_node, text,
177
 
                stuple(b'not-a-real-sha',))
 
178
                          self.module._deserialise_internal_node, text,
 
179
                          stuple(b'not-a-real-sha',))
178
180
 
179
181
    def test_raises_on_non_internal(self):
180
182
        self.assertDeserialiseErrors(b'')
257
259
 
258
260
    def test_file(self):
259
261
        self.assertBytesToTextKey((b'file-id', b'revision-id'),
260
 
                 b'file: file-id\nparent-id\nname\nrevision-id\n'
261
 
                 b'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
 
262
                                  b'file: file-id\nparent-id\nname\nrevision-id\n'
 
263
                                  b'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
262
264
 
263
265
    def test_invalid_no_kind(self):
264
266
        self.assertBytesToTextKeyRaises(
265
 
                 b'file  file-id\nparent-id\nname\nrevision-id\n'
266
 
                 b'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
 
267
            b'file  file-id\nparent-id\nname\nrevision-id\n'
 
268
            b'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
267
269
 
268
270
    def test_invalid_no_space(self):
269
271
        self.assertBytesToTextKeyRaises(
270
 
                 b'file:file-id\nparent-id\nname\nrevision-id\n'
271
 
                 b'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
 
272
            b'file:file-id\nparent-id\nname\nrevision-id\n'
 
273
            b'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
272
274
 
273
275
    def test_invalid_too_short_file_id(self):
274
276
        self.assertBytesToTextKeyRaises(b'file:file-id')
281
283
 
282
284
    def test_dir(self):
283
285
        self.assertBytesToTextKey((b'dir-id', b'revision-id'),
284
 
                 b'dir: dir-id\nparent-id\nname\nrevision-id')
 
286
                                  b'dir: dir-id\nparent-id\nname\nrevision-id')