/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: 2020-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

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
 
23
24
def load_tests(loader, standard_tests, pattern):
24
25
    suite, _ = tests.permute_tests_for_extension(standard_tests, loader,
25
 
        'breezy.util._bencode_py', 'breezy._bencode_pyx')
 
26
                                                 'breezy.util._bencode_py', 'breezy._bencode_pyx')
26
27
    return suite
27
28
 
28
29
 
 
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
 
29
45
class TestBencodeDecode(tests.TestCase):
30
46
 
31
47
    module = None
76
92
        self._run_check_error(ValueError, b'00:')
77
93
        self._run_check_error(ValueError, b'35208734823ljdahflajhdf')
78
94
        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
 
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
83
99
        self._run_check_error(ValueError, (b'1' * 1000) + b':')
84
100
 
85
101
    def test_list(self):
90
106
        self._check([[b'Alice', b'Bob'], [2, 3]], b'll5:Alice3:Bobeli2ei3eee')
91
107
 
92
108
    def test_list_deepnested(self):
93
 
        self._run_check_error(RuntimeError, (b"l" * 10000) + (b"e" * 10000))
 
109
        with RecursionLimit():
 
110
            self._run_check_error(RuntimeError, (b"l" * 100) + (b"e" * 100))
94
111
 
95
112
    def test_malformed_list(self):
96
113
        self._run_check_error(ValueError, b'l')
101
118
 
102
119
    def test_dict(self):
103
120
        self._check({}, b'de')
104
 
        self._check({b'':3}, b'd0:i3ee')
 
121
        self._check({b'': 3}, b'd0:i3ee')
105
122
        self._check({b'age': 25, b'eyes': b'blue'}, b'd3:agei25e4:eyes4:bluee')
106
123
        self._check({b'spam.mp3': {b'author': b'Alice', b'length': 100000}},
107
 
            b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee')
 
124
                    b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee')
108
125
 
109
126
    def test_dict_deepnested(self):
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))
 
127
        with RecursionLimit():
 
128
            self._run_check_error(
 
129
                RuntimeError, (b"d0:" * 1000) + b'i1e' + (b"e" * 1000))
118
130
 
119
131
    def test_malformed_dict(self):
120
132
        self._run_check_error(ValueError, b'd')
184
196
    def test_list_deep_nested(self):
185
197
        top = []
186
198
        l = top
187
 
        for i in range(10000):
 
199
        for i in range(1000):
188
200
            l.append([])
189
201
            l = l[0]
190
 
        self.assertRaises(RuntimeError, self.module.bencode, top)
 
202
        with RecursionLimit():
 
203
            self.assertRaises(RuntimeError, self.module.bencode, top)
191
204
 
192
205
    def test_dict(self):
193
206
        self._check(b'de', {})
194
207
        self._check(b'd3:agei25e4:eyes4:bluee', {b'age': 25, b'eyes': b'blue'})
195
208
        self._check(b'd8:spam.mp3d6:author5:Alice6:lengthi100000eee',
196
 
            {b'spam.mp3': {b'author': b'Alice', b'length': 100000}})
 
209
                    {b'spam.mp3': {b'author': b'Alice', b'length': 100000}})
197
210
 
198
211
    def test_dict_deep_nested(self):
199
212
        d = top = {}
200
 
        for i in range(10000):
 
213
        for i in range(1000):
201
214
            d[b''] = {}
202
215
            d = d[b'']
203
 
        self.assertRaises(RuntimeError, self.module.bencode, top)
 
216
        with RecursionLimit():
 
217
            self.assertRaises(RuntimeError, self.module.bencode, top)
204
218
 
205
219
    def test_bencached(self):
206
220
        self._check(b'i3e', self.module.Bencached(self.module.bencode(3)))
211
225
    def test_bool(self):
212
226
        self._check(b'i1e', True)
213
227
        self._check(b'i0e', False)
214