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

  • Committer: Jelmer Vernooij
  • Date: 2018-08-23 01:36:15 UTC
  • mto: This revision was merged to the branch mainline in revision 7089.
  • Revision ID: jelmer@jelmer.uk-20180823013615-ndckfn0vqyvjmgqi
Fix some stream tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test__bencode.py
1
 
# Copyright (C) 2007, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2007, 2009, 2010, 2016 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests for bencode structured encoding"""
18
18
 
19
 
from bzrlib import tests
20
 
 
21
 
def load_tests(standard_tests, module, loader):
 
19
import sys
 
20
 
 
21
from .. import tests
 
22
 
 
23
def load_tests(loader, standard_tests, pattern):
22
24
    suite, _ = tests.permute_tests_for_extension(standard_tests, loader,
23
 
        'bzrlib.util._bencode_py', 'bzrlib._bencode_pyx')
 
25
        'breezy.util._bencode_py', 'breezy._bencode_pyx')
24
26
    return suite
25
27
 
26
28
 
 
29
class RecursionLimit(object):
 
30
    """Context manager that lowers recursion limit for testing."""
 
31
 
 
32
    def __init__(self, limit=100):
 
33
        self._new_limit = limit
 
34
        self._old_limit = sys.getrecursionlimit()
 
35
 
 
36
    def __enter__(self):
 
37
        sys.setrecursionlimit(self._new_limit)
 
38
        return self
 
39
 
 
40
    def __exit__(self, *exc_info):
 
41
        sys.setrecursionlimit(self._old_limit)
 
42
 
 
43
 
27
44
class TestBencodeDecode(tests.TestCase):
28
45
 
29
46
    module = None
30
47
 
31
48
    def _check(self, expected, source):
32
 
        self.assertEquals(expected, self.module.bdecode(source))
 
49
        self.assertEqual(expected, self.module.bdecode(source))
33
50
 
34
51
    def _run_check_error(self, exc, bad):
35
52
        """Check that bdecoding a string raises a particular exception."""
36
53
        self.assertRaises(exc, self.module.bdecode, bad)
37
54
 
38
55
    def test_int(self):
39
 
        self._check(0, 'i0e')
40
 
        self._check(4, 'i4e')
41
 
        self._check(123456789, 'i123456789e')
42
 
        self._check(-10, 'i-10e')
43
 
        self._check(int('1' * 1000), 'i' + ('1' * 1000) + 'e')
 
56
        self._check(0, b'i0e')
 
57
        self._check(4, b'i4e')
 
58
        self._check(123456789, b'i123456789e')
 
59
        self._check(-10, b'i-10e')
 
60
        self._check(int('1' * 1000), b'i' + (b'1' * 1000) + b'e')
44
61
 
45
62
    def test_long(self):
46
 
        self._check(12345678901234567890L, 'i12345678901234567890e')
47
 
        self._check(-12345678901234567890L, 'i-12345678901234567890e')
 
63
        self._check(12345678901234567890, b'i12345678901234567890e')
 
64
        self._check(-12345678901234567890, b'i-12345678901234567890e')
48
65
 
49
66
    def test_malformed_int(self):
50
 
        self._run_check_error(ValueError, 'ie')
51
 
        self._run_check_error(ValueError, 'i-e')
52
 
        self._run_check_error(ValueError, 'i-010e')
53
 
        self._run_check_error(ValueError, 'i-0e')
54
 
        self._run_check_error(ValueError, 'i00e')
55
 
        self._run_check_error(ValueError, 'i01e')
56
 
        self._run_check_error(ValueError, 'i-03e')
57
 
        self._run_check_error(ValueError, 'i')
58
 
        self._run_check_error(ValueError, 'i123')
59
 
        self._run_check_error(ValueError, 'i341foo382e')
 
67
        self._run_check_error(ValueError, b'ie')
 
68
        self._run_check_error(ValueError, b'i-e')
 
69
        self._run_check_error(ValueError, b'i-010e')
 
70
        self._run_check_error(ValueError, b'i-0e')
 
71
        self._run_check_error(ValueError, b'i00e')
 
72
        self._run_check_error(ValueError, b'i01e')
 
73
        self._run_check_error(ValueError, b'i-03e')
 
74
        self._run_check_error(ValueError, b'i')
 
75
        self._run_check_error(ValueError, b'i123')
 
76
        self._run_check_error(ValueError, b'i341foo382e')
60
77
 
61
78
    def test_string(self):
62
 
        self._check('', '0:')
63
 
        self._check('abc', '3:abc')
64
 
        self._check('1234567890', '10:1234567890')
 
79
        self._check(b'', b'0:')
 
80
        self._check(b'abc', b'3:abc')
 
81
        self._check(b'1234567890', b'10:1234567890')
65
82
 
66
83
    def test_large_string(self):
67
 
        self.assertRaises(ValueError, self.module.bdecode, "2147483639:foo")
 
84
        self.assertRaises(ValueError, self.module.bdecode, b"2147483639:foo")
68
85
 
69
86
    def test_malformed_string(self):
70
 
        self._run_check_error(ValueError, '10:x')
71
 
        self._run_check_error(ValueError, '10:')
72
 
        self._run_check_error(ValueError, '10')
73
 
        self._run_check_error(ValueError, '01:x')
74
 
        self._run_check_error(ValueError, '00:')
75
 
        self._run_check_error(ValueError, '35208734823ljdahflajhdf')
76
 
        self._run_check_error(ValueError, '432432432432432:foo')
77
 
        self._run_check_error(ValueError, ' 1:x') # leading whitespace
78
 
        self._run_check_error(ValueError, '-1:x') # negative
79
 
        self._run_check_error(ValueError, '1 x') # space vs colon
80
 
        self._run_check_error(ValueError, '1x') # missing colon
81
 
        self._run_check_error(ValueError, ('1' * 1000) + ':')
 
87
        self._run_check_error(ValueError, b'10:x')
 
88
        self._run_check_error(ValueError, b'10:')
 
89
        self._run_check_error(ValueError, b'10')
 
90
        self._run_check_error(ValueError, b'01:x')
 
91
        self._run_check_error(ValueError, b'00:')
 
92
        self._run_check_error(ValueError, b'35208734823ljdahflajhdf')
 
93
        self._run_check_error(ValueError, b'432432432432432:foo')
 
94
        self._run_check_error(ValueError, b' 1:x') # leading whitespace
 
95
        self._run_check_error(ValueError, b'-1:x') # negative
 
96
        self._run_check_error(ValueError, b'1 x') # space vs colon
 
97
        self._run_check_error(ValueError, b'1x') # missing colon
 
98
        self._run_check_error(ValueError, (b'1' * 1000) + b':')
82
99
 
83
100
    def test_list(self):
84
 
        self._check([], 'le')
85
 
        self._check(['', '', ''], 'l0:0:0:e')
86
 
        self._check([1, 2, 3], 'li1ei2ei3ee')
87
 
        self._check(['asd', 'xy'], 'l3:asd2:xye')
88
 
        self._check([['Alice', 'Bob'], [2, 3]], 'll5:Alice3:Bobeli2ei3eee')
 
101
        self._check([], b'le')
 
102
        self._check([b'', b'', b''], b'l0:0:0:e')
 
103
        self._check([1, 2, 3], b'li1ei2ei3ee')
 
104
        self._check([b'asd', b'xy'], b'l3:asd2:xye')
 
105
        self._check([[b'Alice', b'Bob'], [2, 3]], b'll5:Alice3:Bobeli2ei3eee')
89
106
 
90
107
    def test_list_deepnested(self):
91
 
        self._run_check_error(RuntimeError, ("l" * 10000) + ("e" * 10000))
 
108
        with RecursionLimit():
 
109
            self._run_check_error(RuntimeError, (b"l" * 100) + (b"e" * 100))
92
110
 
93
111
    def test_malformed_list(self):
94
 
        self._run_check_error(ValueError, 'l')
95
 
        self._run_check_error(ValueError, 'l01:ae')
96
 
        self._run_check_error(ValueError, 'l0:')
97
 
        self._run_check_error(ValueError, 'li1e')
98
 
        self._run_check_error(ValueError, 'l-3:e')
 
112
        self._run_check_error(ValueError, b'l')
 
113
        self._run_check_error(ValueError, b'l01:ae')
 
114
        self._run_check_error(ValueError, b'l0:')
 
115
        self._run_check_error(ValueError, b'li1e')
 
116
        self._run_check_error(ValueError, b'l-3:e')
99
117
 
100
118
    def test_dict(self):
101
 
        self._check({}, 'de')
102
 
        self._check({'':3}, 'd0:i3ee')
103
 
        self._check({'age': 25, 'eyes': 'blue'}, 'd3:agei25e4:eyes4:bluee')
104
 
        self._check({'spam.mp3': {'author': 'Alice', 'length': 100000}},
105
 
                            'd8:spam.mp3d6:author5:Alice6:lengthi100000eee')
 
119
        self._check({}, b'de')
 
120
        self._check({b'':3}, b'd0:i3ee')
 
121
        self._check({b'age': 25, b'eyes': b'blue'}, b'd3:agei25e4:eyes4:bluee')
 
122
        self._check({b'spam.mp3': {b'author': b'Alice', b'length': 100000}},
 
123
            b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee')
106
124
 
107
125
    def test_dict_deepnested(self):
108
 
        self._run_check_error(RuntimeError, ("d0:" * 10000) + 'i1e' + ("e" * 10000))
 
126
        with RecursionLimit():
 
127
            self._run_check_error(
 
128
                RuntimeError, (b"d0:" * 1000) + b'i1e' + (b"e" * 1000))
109
129
 
110
130
    def test_malformed_dict(self):
111
 
        self._run_check_error(ValueError, 'd')
112
 
        self._run_check_error(ValueError, 'defoobar')
113
 
        self._run_check_error(ValueError, 'd3:fooe')
114
 
        self._run_check_error(ValueError, 'di1e0:e')
115
 
        self._run_check_error(ValueError, 'd1:b0:1:a0:e')
116
 
        self._run_check_error(ValueError, 'd1:a0:1:a0:e')
117
 
        self._run_check_error(ValueError, 'd0:0:')
118
 
        self._run_check_error(ValueError, 'd0:')
119
 
        self._run_check_error(ValueError, 'd432432432432432432:e')
 
131
        self._run_check_error(ValueError, b'd')
 
132
        self._run_check_error(ValueError, b'defoobar')
 
133
        self._run_check_error(ValueError, b'd3:fooe')
 
134
        self._run_check_error(ValueError, b'di1e0:e')
 
135
        self._run_check_error(ValueError, b'd1:b0:1:a0:e')
 
136
        self._run_check_error(ValueError, b'd1:a0:1:a0:e')
 
137
        self._run_check_error(ValueError, b'd0:0:')
 
138
        self._run_check_error(ValueError, b'd0:')
 
139
        self._run_check_error(ValueError, b'd432432432432432432:e')
120
140
 
121
141
    def test_empty_string(self):
122
 
        self.assertRaises(ValueError, self.module.bdecode, '')
 
142
        self.assertRaises(ValueError, self.module.bdecode, b'')
123
143
 
124
144
    def test_junk(self):
125
 
        self._run_check_error(ValueError, 'i6easd')
126
 
        self._run_check_error(ValueError, '2:abfdjslhfld')
127
 
        self._run_check_error(ValueError, '0:0:')
128
 
        self._run_check_error(ValueError, 'leanfdldjfh')
 
145
        self._run_check_error(ValueError, b'i6easd')
 
146
        self._run_check_error(ValueError, b'2:abfdjslhfld')
 
147
        self._run_check_error(ValueError, b'0:0:')
 
148
        self._run_check_error(ValueError, b'leanfdldjfh')
129
149
 
130
150
    def test_unknown_object(self):
131
 
        self.assertRaises(ValueError, self.module.bdecode, 'relwjhrlewjh')
 
151
        self.assertRaises(ValueError, self.module.bdecode, b'relwjhrlewjh')
132
152
 
133
153
    def test_unsupported_type(self):
134
154
        self._run_check_error(TypeError, float(1.5))
146
166
    module = None
147
167
 
148
168
    def _check(self, expected, source):
149
 
        self.assertEquals(expected, self.module.bencode(source))
 
169
        self.assertEqual(expected, self.module.bencode(source))
150
170
 
151
171
    def test_int(self):
152
 
        self._check('i4e', 4)
153
 
        self._check('i0e', 0)
154
 
        self._check('i-10e', -10)
 
172
        self._check(b'i4e', 4)
 
173
        self._check(b'i0e', 0)
 
174
        self._check(b'i-10e', -10)
155
175
 
156
176
    def test_long(self):
157
 
        self._check('i12345678901234567890e', 12345678901234567890L)
158
 
        self._check('i-12345678901234567890e', -12345678901234567890L)
 
177
        self._check(b'i12345678901234567890e', 12345678901234567890)
 
178
        self._check(b'i-12345678901234567890e', -12345678901234567890)
159
179
 
160
180
    def test_string(self):
161
 
        self._check('0:', '')
162
 
        self._check('3:abc', 'abc')
163
 
        self._check('10:1234567890', '1234567890')
 
181
        self._check(b'0:', b'')
 
182
        self._check(b'3:abc', b'abc')
 
183
        self._check(b'10:1234567890', b'1234567890')
164
184
 
165
185
    def test_list(self):
166
 
        self._check('le', [])
167
 
        self._check('li1ei2ei3ee', [1, 2, 3])
168
 
        self._check('ll5:Alice3:Bobeli2ei3eee', [['Alice', 'Bob'], [2, 3]])
 
186
        self._check(b'le', [])
 
187
        self._check(b'li1ei2ei3ee', [1, 2, 3])
 
188
        self._check(b'll5:Alice3:Bobeli2ei3eee', [[b'Alice', b'Bob'], [2, 3]])
169
189
 
170
190
    def test_list_as_tuple(self):
171
 
        self._check('le', ())
172
 
        self._check('li1ei2ei3ee', (1, 2, 3))
173
 
        self._check('ll5:Alice3:Bobeli2ei3eee', (('Alice', 'Bob'), (2, 3)))
 
191
        self._check(b'le', ())
 
192
        self._check(b'li1ei2ei3ee', (1, 2, 3))
 
193
        self._check(b'll5:Alice3:Bobeli2ei3eee', ((b'Alice', b'Bob'), (2, 3)))
174
194
 
175
195
    def test_list_deep_nested(self):
176
196
        top = []
177
197
        l = top
178
 
        for i in range(10000):
 
198
        for i in range(1000):
179
199
            l.append([])
180
200
            l = l[0]
181
 
        self.assertRaises(RuntimeError, self.module.bencode, 
182
 
            top)
 
201
        with RecursionLimit():
 
202
            self.assertRaises(RuntimeError, self.module.bencode, top)
183
203
 
184
204
    def test_dict(self):
185
 
        self._check('de', {})
186
 
        self._check('d3:agei25e4:eyes4:bluee', {'age': 25, 'eyes': 'blue'})
187
 
        self._check('d8:spam.mp3d6:author5:Alice6:lengthi100000eee',
188
 
                            {'spam.mp3': {'author': 'Alice',
189
 
                                          'length': 100000}})
 
205
        self._check(b'de', {})
 
206
        self._check(b'd3:agei25e4:eyes4:bluee', {b'age': 25, b'eyes': b'blue'})
 
207
        self._check(b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee',
 
208
            {b'spam.mp3': {b'author': b'Alice', b'length': 100000}})
190
209
 
191
210
    def test_dict_deep_nested(self):
192
211
        d = top = {}
193
 
        for i in range(10000):
194
 
            d[''] = {}
195
 
            d = d['']
196
 
        self.assertRaises(RuntimeError, self.module.bencode, 
197
 
            top)
 
212
        for i in range(1000):
 
213
            d[b''] = {}
 
214
            d = d[b'']
 
215
        with RecursionLimit():
 
216
            self.assertRaises(RuntimeError, self.module.bencode, top)
198
217
 
199
218
    def test_bencached(self):
200
 
        self._check('i3e', self.module.Bencached(self.module.bencode(3)))
 
219
        self._check(b'i3e', self.module.Bencached(self.module.bencode(3)))
201
220
 
202
221
    def test_invalid_dict(self):
203
 
        self.assertRaises(TypeError, self.module.bencode, {1:"foo"})
 
222
        self.assertRaises(TypeError, self.module.bencode, {1: b"foo"})
204
223
 
205
224
    def test_bool(self):
206
 
        self._check('i1e', True)
207
 
        self._check('i0e', False)
 
225
        self._check(b'i1e', True)
 
226
        self._check(b'i0e', False)
208
227