/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 bzrlib/tests/test__bencode.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test__bencode.py
1
 
# Copyright (C) 2007, 2009, 2010, 2016 Canonical Ltd
 
1
# Copyright (C) 2007, 2009, 2010 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
18
18
 
19
19
import sys
20
20
 
21
 
from .. import tests
 
21
from bzrlib import tests
22
22
 
23
 
def load_tests(loader, standard_tests, pattern):
 
23
def load_tests(standard_tests, module, loader):
24
24
    suite, _ = tests.permute_tests_for_extension(standard_tests, loader,
25
 
        'breezy.util._bencode_py', 'breezy._bencode_pyx')
 
25
        'bzrlib.util._bencode_py', 'bzrlib._bencode_pyx')
26
26
    return suite
27
27
 
28
28
 
31
31
    module = None
32
32
 
33
33
    def _check(self, expected, source):
34
 
        self.assertEqual(expected, self.module.bdecode(source))
 
34
        self.assertEquals(expected, self.module.bdecode(source))
35
35
 
36
36
    def _run_check_error(self, exc, bad):
37
37
        """Check that bdecoding a string raises a particular exception."""
38
38
        self.assertRaises(exc, self.module.bdecode, bad)
39
39
 
40
40
    def test_int(self):
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')
 
41
        self._check(0, 'i0e')
 
42
        self._check(4, 'i4e')
 
43
        self._check(123456789, 'i123456789e')
 
44
        self._check(-10, 'i-10e')
 
45
        self._check(int('1' * 1000), 'i' + ('1' * 1000) + 'e')
46
46
 
47
47
    def test_long(self):
48
 
        self._check(12345678901234567890, b'i12345678901234567890e')
49
 
        self._check(-12345678901234567890, b'i-12345678901234567890e')
 
48
        self._check(12345678901234567890L, 'i12345678901234567890e')
 
49
        self._check(-12345678901234567890L, 'i-12345678901234567890e')
50
50
 
51
51
    def test_malformed_int(self):
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')
 
52
        self._run_check_error(ValueError, 'ie')
 
53
        self._run_check_error(ValueError, 'i-e')
 
54
        self._run_check_error(ValueError, 'i-010e')
 
55
        self._run_check_error(ValueError, 'i-0e')
 
56
        self._run_check_error(ValueError, 'i00e')
 
57
        self._run_check_error(ValueError, 'i01e')
 
58
        self._run_check_error(ValueError, 'i-03e')
 
59
        self._run_check_error(ValueError, 'i')
 
60
        self._run_check_error(ValueError, 'i123')
 
61
        self._run_check_error(ValueError, 'i341foo382e')
62
62
 
63
63
    def test_string(self):
64
 
        self._check(b'', b'0:')
65
 
        self._check(b'abc', b'3:abc')
66
 
        self._check(b'1234567890', b'10:1234567890')
 
64
        self._check('', '0:')
 
65
        self._check('abc', '3:abc')
 
66
        self._check('1234567890', '10:1234567890')
67
67
 
68
68
    def test_large_string(self):
69
 
        self.assertRaises(ValueError, self.module.bdecode, b"2147483639:foo")
 
69
        self.assertRaises(ValueError, self.module.bdecode, "2147483639:foo")
70
70
 
71
71
    def test_malformed_string(self):
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':')
 
72
        self._run_check_error(ValueError, '10:x')
 
73
        self._run_check_error(ValueError, '10:')
 
74
        self._run_check_error(ValueError, '10')
 
75
        self._run_check_error(ValueError, '01:x')
 
76
        self._run_check_error(ValueError, '00:')
 
77
        self._run_check_error(ValueError, '35208734823ljdahflajhdf')
 
78
        self._run_check_error(ValueError, '432432432432432:foo')
 
79
        self._run_check_error(ValueError, ' 1:x') # leading whitespace
 
80
        self._run_check_error(ValueError, '-1:x') # negative
 
81
        self._run_check_error(ValueError, '1 x') # space vs colon
 
82
        self._run_check_error(ValueError, '1x') # missing colon
 
83
        self._run_check_error(ValueError, ('1' * 1000) + ':')
84
84
 
85
85
    def test_list(self):
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')
 
86
        self._check([], 'le')
 
87
        self._check(['', '', ''], 'l0:0:0:e')
 
88
        self._check([1, 2, 3], 'li1ei2ei3ee')
 
89
        self._check(['asd', 'xy'], 'l3:asd2:xye')
 
90
        self._check([['Alice', 'Bob'], [2, 3]], 'll5:Alice3:Bobeli2ei3eee')
91
91
 
92
92
    def test_list_deepnested(self):
93
 
        self._run_check_error(RuntimeError, (b"l" * 10000) + (b"e" * 10000))
 
93
        self._run_check_error(RuntimeError, ("l" * 10000) + ("e" * 10000))
94
94
 
95
95
    def test_malformed_list(self):
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')
 
96
        self._run_check_error(ValueError, 'l')
 
97
        self._run_check_error(ValueError, 'l01:ae')
 
98
        self._run_check_error(ValueError, 'l0:')
 
99
        self._run_check_error(ValueError, 'li1e')
 
100
        self._run_check_error(ValueError, 'l-3:e')
101
101
 
102
102
    def test_dict(self):
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')
 
103
        self._check({}, 'de')
 
104
        self._check({'':3}, 'd0:i3ee')
 
105
        self._check({'age': 25, 'eyes': 'blue'}, 'd3:agei25e4:eyes4:bluee')
 
106
        self._check({'spam.mp3': {'author': 'Alice', 'length': 100000}},
 
107
                            'd8:spam.mp3d6:author5:Alice6:lengthi100000eee')
108
108
 
109
109
    def test_dict_deepnested(self):
110
110
        # The recursion here provokes CPython into emitting a warning on
114
114
        # avoid distracting noise in the test output.
115
115
        self.overrideAttr(sys, 'stderr', self._log_file)
116
116
        self._run_check_error(
117
 
            RuntimeError, (b"d0:" * 10000) + b'i1e' + (b"e" * 10000))
 
117
            RuntimeError, ("d0:" * 10000) + 'i1e' + ("e" * 10000))
118
118
 
119
119
    def test_malformed_dict(self):
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
        self._run_check_error(ValueError, 'd')
 
121
        self._run_check_error(ValueError, 'defoobar')
 
122
        self._run_check_error(ValueError, 'd3:fooe')
 
123
        self._run_check_error(ValueError, 'di1e0:e')
 
124
        self._run_check_error(ValueError, 'd1:b0:1:a0:e')
 
125
        self._run_check_error(ValueError, 'd1:a0:1:a0:e')
 
126
        self._run_check_error(ValueError, 'd0:0:')
 
127
        self._run_check_error(ValueError, 'd0:')
 
128
        self._run_check_error(ValueError, 'd432432432432432432:e')
129
129
 
130
130
    def test_empty_string(self):
131
 
        self.assertRaises(ValueError, self.module.bdecode, b'')
 
131
        self.assertRaises(ValueError, self.module.bdecode, '')
132
132
 
133
133
    def test_junk(self):
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')
 
134
        self._run_check_error(ValueError, 'i6easd')
 
135
        self._run_check_error(ValueError, '2:abfdjslhfld')
 
136
        self._run_check_error(ValueError, '0:0:')
 
137
        self._run_check_error(ValueError, 'leanfdldjfh')
138
138
 
139
139
    def test_unknown_object(self):
140
 
        self.assertRaises(ValueError, self.module.bdecode, b'relwjhrlewjh')
 
140
        self.assertRaises(ValueError, self.module.bdecode, 'relwjhrlewjh')
141
141
 
142
142
    def test_unsupported_type(self):
143
143
        self._run_check_error(TypeError, float(1.5))
155
155
    module = None
156
156
 
157
157
    def _check(self, expected, source):
158
 
        self.assertEqual(expected, self.module.bencode(source))
 
158
        self.assertEquals(expected, self.module.bencode(source))
159
159
 
160
160
    def test_int(self):
161
 
        self._check(b'i4e', 4)
162
 
        self._check(b'i0e', 0)
163
 
        self._check(b'i-10e', -10)
 
161
        self._check('i4e', 4)
 
162
        self._check('i0e', 0)
 
163
        self._check('i-10e', -10)
164
164
 
165
165
    def test_long(self):
166
 
        self._check(b'i12345678901234567890e', 12345678901234567890)
167
 
        self._check(b'i-12345678901234567890e', -12345678901234567890)
 
166
        self._check('i12345678901234567890e', 12345678901234567890L)
 
167
        self._check('i-12345678901234567890e', -12345678901234567890L)
168
168
 
169
169
    def test_string(self):
170
 
        self._check(b'0:', b'')
171
 
        self._check(b'3:abc', b'abc')
172
 
        self._check(b'10:1234567890', b'1234567890')
 
170
        self._check('0:', '')
 
171
        self._check('3:abc', 'abc')
 
172
        self._check('10:1234567890', '1234567890')
173
173
 
174
174
    def test_list(self):
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]])
 
175
        self._check('le', [])
 
176
        self._check('li1ei2ei3ee', [1, 2, 3])
 
177
        self._check('ll5:Alice3:Bobeli2ei3eee', [['Alice', 'Bob'], [2, 3]])
178
178
 
179
179
    def test_list_as_tuple(self):
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)))
 
180
        self._check('le', ())
 
181
        self._check('li1ei2ei3ee', (1, 2, 3))
 
182
        self._check('ll5:Alice3:Bobeli2ei3eee', (('Alice', 'Bob'), (2, 3)))
183
183
 
184
184
    def test_list_deep_nested(self):
185
185
        top = []
187
187
        for i in range(10000):
188
188
            l.append([])
189
189
            l = l[0]
190
 
        self.assertRaises(RuntimeError, self.module.bencode, top)
 
190
        self.assertRaises(RuntimeError, self.module.bencode, 
 
191
            top)
191
192
 
192
193
    def test_dict(self):
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}})
 
194
        self._check('de', {})
 
195
        self._check('d3:agei25e4:eyes4:bluee', {'age': 25, 'eyes': 'blue'})
 
196
        self._check('d8:spam.mp3d6:author5:Alice6:lengthi100000eee',
 
197
                            {'spam.mp3': {'author': 'Alice',
 
198
                                          'length': 100000}})
197
199
 
198
200
    def test_dict_deep_nested(self):
199
201
        d = top = {}
200
202
        for i in range(10000):
201
 
            d[b''] = {}
202
 
            d = d[b'']
203
 
        self.assertRaises(RuntimeError, self.module.bencode, top)
 
203
            d[''] = {}
 
204
            d = d['']
 
205
        self.assertRaises(RuntimeError, self.module.bencode, 
 
206
            top)
204
207
 
205
208
    def test_bencached(self):
206
 
        self._check(b'i3e', self.module.Bencached(self.module.bencode(3)))
 
209
        self._check('i3e', self.module.Bencached(self.module.bencode(3)))
207
210
 
208
211
    def test_invalid_dict(self):
209
 
        self.assertRaises(TypeError, self.module.bencode, {1: b"foo"})
 
212
        self.assertRaises(TypeError, self.module.bencode, {1:"foo"})
210
213
 
211
214
    def test_bool(self):
212
 
        self._check(b'i1e', True)
213
 
        self._check(b'i0e', False)
 
215
        self._check('i1e', True)
 
216
        self._check('i0e', False)
214
217