/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-05-06 11:48:54 UTC
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@jelmer.uk-20180506114854-h4qd9ojaqy8wxjsd
Move .mailmap to root.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test__bencode.py
20
20
 
21
21
from .. import tests
22
22
 
23
 
 
24
23
def load_tests(loader, standard_tests, pattern):
25
24
    suite, _ = tests.permute_tests_for_extension(standard_tests, loader,
26
 
                                                 'breezy.util._bencode_py', 'breezy._bencode_pyx')
 
25
        'breezy.util._bencode_py', 'breezy._bencode_pyx')
27
26
    return suite
28
27
 
29
28
 
30
 
class RecursionLimit(object):
31
 
    """Context manager that lowers recursion limit for testing."""
32
 
 
33
 
    def __init__(self, limit=100):
34
 
        self._new_limit = limit
35
 
        self._old_limit = sys.getrecursionlimit()
36
 
 
37
 
    def __enter__(self):
38
 
        sys.setrecursionlimit(self._new_limit)
39
 
        return self
40
 
 
41
 
    def __exit__(self, *exc_info):
42
 
        sys.setrecursionlimit(self._old_limit)
43
 
 
44
 
 
45
29
class TestBencodeDecode(tests.TestCase):
46
30
 
47
31
    module = None
92
76
        self._run_check_error(ValueError, b'00:')
93
77
        self._run_check_error(ValueError, b'35208734823ljdahflajhdf')
94
78
        self._run_check_error(ValueError, b'432432432432432:foo')
95
 
        self._run_check_error(ValueError, b' 1:x')  # leading whitespace
96
 
        self._run_check_error(ValueError, b'-1:x')  # negative
97
 
        self._run_check_error(ValueError, b'1 x')  # space vs colon
98
 
        self._run_check_error(ValueError, b'1x')  # missing colon
 
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
99
83
        self._run_check_error(ValueError, (b'1' * 1000) + b':')
100
84
 
101
85
    def test_list(self):
106
90
        self._check([[b'Alice', b'Bob'], [2, 3]], b'll5:Alice3:Bobeli2ei3eee')
107
91
 
108
92
    def test_list_deepnested(self):
109
 
        with RecursionLimit():
110
 
            self._run_check_error(RuntimeError, (b"l" * 100) + (b"e" * 100))
 
93
        self._run_check_error(RuntimeError, (b"l" * 10000) + (b"e" * 10000))
111
94
 
112
95
    def test_malformed_list(self):
113
96
        self._run_check_error(ValueError, b'l')
118
101
 
119
102
    def test_dict(self):
120
103
        self._check({}, b'de')
121
 
        self._check({b'': 3}, b'd0:i3ee')
 
104
        self._check({b'':3}, b'd0:i3ee')
122
105
        self._check({b'age': 25, b'eyes': b'blue'}, b'd3:agei25e4:eyes4:bluee')
123
106
        self._check({b'spam.mp3': {b'author': b'Alice', b'length': 100000}},
124
 
                    b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee')
 
107
            b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee')
125
108
 
126
109
    def test_dict_deepnested(self):
127
 
        with RecursionLimit():
128
 
            self._run_check_error(
129
 
                RuntimeError, (b"d0:" * 1000) + b'i1e' + (b"e" * 1000))
 
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))
130
118
 
131
119
    def test_malformed_dict(self):
132
120
        self._run_check_error(ValueError, b'd')
196
184
    def test_list_deep_nested(self):
197
185
        top = []
198
186
        l = top
199
 
        for i in range(1000):
 
187
        for i in range(10000):
200
188
            l.append([])
201
189
            l = l[0]
202
 
        with RecursionLimit():
203
 
            self.assertRaises(RuntimeError, self.module.bencode, top)
 
190
        self.assertRaises(RuntimeError, self.module.bencode, top)
204
191
 
205
192
    def test_dict(self):
206
193
        self._check(b'de', {})
207
194
        self._check(b'd3:agei25e4:eyes4:bluee', {b'age': 25, b'eyes': b'blue'})
208
195
        self._check(b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee',
209
 
                    {b'spam.mp3': {b'author': b'Alice', b'length': 100000}})
 
196
            {b'spam.mp3': {b'author': b'Alice', b'length': 100000}})
210
197
 
211
198
    def test_dict_deep_nested(self):
212
199
        d = top = {}
213
 
        for i in range(1000):
 
200
        for i in range(10000):
214
201
            d[b''] = {}
215
202
            d = d[b'']
216
 
        with RecursionLimit():
217
 
            self.assertRaises(RuntimeError, self.module.bencode, top)
 
203
        self.assertRaises(RuntimeError, self.module.bencode, top)
218
204
 
219
205
    def test_bencached(self):
220
206
        self._check(b'i3e', self.module.Bencached(self.module.bencode(3)))
225
211
    def test_bool(self):
226
212
        self._check(b'i1e', True)
227
213
        self._check(b'i0e', False)
 
214