/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-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge 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
31
    module = None
30
32
 
31
33
    def _check(self, expected, source):
32
 
        self.assertEquals(expected, self.module.bdecode(source))
 
34
        self.assertEqual(expected, self.module.bdecode(source))
33
35
 
34
36
    def _run_check_error(self, exc, bad):
35
37
        """Check that bdecoding a string raises a particular exception."""
36
38
        self.assertRaises(exc, self.module.bdecode, bad)
37
39
 
38
40
    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')
 
41
        self._check(0, b'i0e')
 
42
        self._check(4, b'i4e')
 
43
        self._check(123456789, b'i123456789e')
 
44
        self._check(-10, b'i-10e')
 
45
        self._check(int('1' * 1000), b'i' + (b'1' * 1000) + b'e')
44
46
 
45
47
    def test_long(self):
46
 
        self._check(12345678901234567890L, 'i12345678901234567890e')
47
 
        self._check(-12345678901234567890L, 'i-12345678901234567890e')
 
48
        self._check(12345678901234567890, b'i12345678901234567890e')
 
49
        self._check(-12345678901234567890, b'i-12345678901234567890e')
48
50
 
49
51
    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')
 
52
        self._run_check_error(ValueError, b'ie')
 
53
        self._run_check_error(ValueError, b'i-e')
 
54
        self._run_check_error(ValueError, b'i-010e')
 
55
        self._run_check_error(ValueError, b'i-0e')
 
56
        self._run_check_error(ValueError, b'i00e')
 
57
        self._run_check_error(ValueError, b'i01e')
 
58
        self._run_check_error(ValueError, b'i-03e')
 
59
        self._run_check_error(ValueError, b'i')
 
60
        self._run_check_error(ValueError, b'i123')
 
61
        self._run_check_error(ValueError, b'i341foo382e')
60
62
 
61
63
    def test_string(self):
62
 
        self._check('', '0:')
63
 
        self._check('abc', '3:abc')
64
 
        self._check('1234567890', '10:1234567890')
 
64
        self._check(b'', b'0:')
 
65
        self._check(b'abc', b'3:abc')
 
66
        self._check(b'1234567890', b'10:1234567890')
65
67
 
66
68
    def test_large_string(self):
67
 
        self.assertRaises(ValueError, self.module.bdecode, "2147483639:foo")
 
69
        self.assertRaises(ValueError, self.module.bdecode, b"2147483639:foo")
68
70
 
69
71
    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) + ':')
 
72
        self._run_check_error(ValueError, b'10:x')
 
73
        self._run_check_error(ValueError, b'10:')
 
74
        self._run_check_error(ValueError, b'10')
 
75
        self._run_check_error(ValueError, b'01:x')
 
76
        self._run_check_error(ValueError, b'00:')
 
77
        self._run_check_error(ValueError, b'35208734823ljdahflajhdf')
 
78
        self._run_check_error(ValueError, b'432432432432432:foo')
 
79
        self._run_check_error(ValueError, b' 1:x') # leading whitespace
 
80
        self._run_check_error(ValueError, b'-1:x') # negative
 
81
        self._run_check_error(ValueError, b'1 x') # space vs colon
 
82
        self._run_check_error(ValueError, b'1x') # missing colon
 
83
        self._run_check_error(ValueError, (b'1' * 1000) + b':')
82
84
 
83
85
    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')
 
86
        self._check([], b'le')
 
87
        self._check([b'', b'', b''], b'l0:0:0:e')
 
88
        self._check([1, 2, 3], b'li1ei2ei3ee')
 
89
        self._check([b'asd', b'xy'], b'l3:asd2:xye')
 
90
        self._check([[b'Alice', b'Bob'], [2, 3]], b'll5:Alice3:Bobeli2ei3eee')
89
91
 
90
92
    def test_list_deepnested(self):
91
 
        self._run_check_error(RuntimeError, ("l" * 10000) + ("e" * 10000))
 
93
        self._run_check_error(RuntimeError, (b"l" * 10000) + (b"e" * 10000))
92
94
 
93
95
    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')
 
96
        self._run_check_error(ValueError, b'l')
 
97
        self._run_check_error(ValueError, b'l01:ae')
 
98
        self._run_check_error(ValueError, b'l0:')
 
99
        self._run_check_error(ValueError, b'li1e')
 
100
        self._run_check_error(ValueError, b'l-3:e')
99
101
 
100
102
    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')
 
103
        self._check({}, b'de')
 
104
        self._check({b'':3}, b'd0:i3ee')
 
105
        self._check({b'age': 25, b'eyes': b'blue'}, b'd3:agei25e4:eyes4:bluee')
 
106
        self._check({b'spam.mp3': {b'author': b'Alice', b'length': 100000}},
 
107
            b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee')
106
108
 
107
109
    def test_dict_deepnested(self):
108
 
        self._run_check_error(RuntimeError, ("d0:" * 10000) + 'i1e' + ("e" * 10000))
 
110
        # The recursion here provokes CPython into emitting a warning on
 
111
        # stderr, "maximum recursion depth exceeded in __subclasscheck__", due
 
112
        # to running out of stack space while evaluating "except (...):" in
 
113
        # _bencode_py.  This is harmless, so we temporarily override stderr to
 
114
        # avoid distracting noise in the test output.
 
115
        self.overrideAttr(sys, 'stderr', self._log_file)
 
116
        self._run_check_error(
 
117
            RuntimeError, (b"d0:" * 10000) + b'i1e' + (b"e" * 10000))
109
118
 
110
119
    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')
 
120
        self._run_check_error(ValueError, b'd')
 
121
        self._run_check_error(ValueError, b'defoobar')
 
122
        self._run_check_error(ValueError, b'd3:fooe')
 
123
        self._run_check_error(ValueError, b'di1e0:e')
 
124
        self._run_check_error(ValueError, b'd1:b0:1:a0:e')
 
125
        self._run_check_error(ValueError, b'd1:a0:1:a0:e')
 
126
        self._run_check_error(ValueError, b'd0:0:')
 
127
        self._run_check_error(ValueError, b'd0:')
 
128
        self._run_check_error(ValueError, b'd432432432432432432:e')
120
129
 
121
130
    def test_empty_string(self):
122
 
        self.assertRaises(ValueError, self.module.bdecode, '')
 
131
        self.assertRaises(ValueError, self.module.bdecode, b'')
123
132
 
124
133
    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')
 
134
        self._run_check_error(ValueError, b'i6easd')
 
135
        self._run_check_error(ValueError, b'2:abfdjslhfld')
 
136
        self._run_check_error(ValueError, b'0:0:')
 
137
        self._run_check_error(ValueError, b'leanfdldjfh')
129
138
 
130
139
    def test_unknown_object(self):
131
 
        self.assertRaises(ValueError, self.module.bdecode, 'relwjhrlewjh')
 
140
        self.assertRaises(ValueError, self.module.bdecode, b'relwjhrlewjh')
132
141
 
133
142
    def test_unsupported_type(self):
134
143
        self._run_check_error(TypeError, float(1.5))
146
155
    module = None
147
156
 
148
157
    def _check(self, expected, source):
149
 
        self.assertEquals(expected, self.module.bencode(source))
 
158
        self.assertEqual(expected, self.module.bencode(source))
150
159
 
151
160
    def test_int(self):
152
 
        self._check('i4e', 4)
153
 
        self._check('i0e', 0)
154
 
        self._check('i-10e', -10)
 
161
        self._check(b'i4e', 4)
 
162
        self._check(b'i0e', 0)
 
163
        self._check(b'i-10e', -10)
155
164
 
156
165
    def test_long(self):
157
 
        self._check('i12345678901234567890e', 12345678901234567890L)
158
 
        self._check('i-12345678901234567890e', -12345678901234567890L)
 
166
        self._check(b'i12345678901234567890e', 12345678901234567890)
 
167
        self._check(b'i-12345678901234567890e', -12345678901234567890)
159
168
 
160
169
    def test_string(self):
161
 
        self._check('0:', '')
162
 
        self._check('3:abc', 'abc')
163
 
        self._check('10:1234567890', '1234567890')
 
170
        self._check(b'0:', b'')
 
171
        self._check(b'3:abc', b'abc')
 
172
        self._check(b'10:1234567890', b'1234567890')
164
173
 
165
174
    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]])
 
175
        self._check(b'le', [])
 
176
        self._check(b'li1ei2ei3ee', [1, 2, 3])
 
177
        self._check(b'll5:Alice3:Bobeli2ei3eee', [[b'Alice', b'Bob'], [2, 3]])
169
178
 
170
179
    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)))
 
180
        self._check(b'le', ())
 
181
        self._check(b'li1ei2ei3ee', (1, 2, 3))
 
182
        self._check(b'll5:Alice3:Bobeli2ei3eee', ((b'Alice', b'Bob'), (2, 3)))
174
183
 
175
184
    def test_list_deep_nested(self):
176
185
        top = []
178
187
        for i in range(10000):
179
188
            l.append([])
180
189
            l = l[0]
181
 
        self.assertRaises(RuntimeError, self.module.bencode, 
182
 
            top)
 
190
        self.assertRaises(RuntimeError, self.module.bencode, top)
183
191
 
184
192
    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}})
 
193
        self._check(b'de', {})
 
194
        self._check(b'd3:agei25e4:eyes4:bluee', {b'age': 25, b'eyes': b'blue'})
 
195
        self._check(b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee',
 
196
            {b'spam.mp3': {b'author': b'Alice', b'length': 100000}})
190
197
 
191
198
    def test_dict_deep_nested(self):
192
199
        d = top = {}
193
200
        for i in range(10000):
194
 
            d[''] = {}
195
 
            d = d['']
196
 
        self.assertRaises(RuntimeError, self.module.bencode, 
197
 
            top)
 
201
            d[b''] = {}
 
202
            d = d[b'']
 
203
        self.assertRaises(RuntimeError, self.module.bencode, top)
198
204
 
199
205
    def test_bencached(self):
200
 
        self._check('i3e', self.module.Bencached(self.module.bencode(3)))
 
206
        self._check(b'i3e', self.module.Bencached(self.module.bencode(3)))
201
207
 
202
208
    def test_invalid_dict(self):
203
 
        self.assertRaises(TypeError, self.module.bencode, {1:"foo"})
 
209
        self.assertRaises(TypeError, self.module.bencode, {1: b"foo"})
204
210
 
205
211
    def test_bool(self):
206
 
        self._check('i1e', True)
207
 
        self._check('i0e', False)
 
212
        self._check(b'i1e', True)
 
213
        self._check(b'i0e', False)
208
214