/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: Andrew Bennetts
  • Date: 2009-10-21 11:13:40 UTC
  • mto: This revision was merged to the branch mainline in revision 4762.
  • Revision ID: andrew.bennetts@canonical.com-20091021111340-w7x4d5yf83qwjncc
Add test that WSGI glue allows request handlers to access paths above that request's. backing transport, so long as it is within the WSGI app's backing transport.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bencode.py
1
 
# Copyright (C) 2007, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2007 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
19
19
from bzrlib import tests
20
20
 
21
21
def load_tests(standard_tests, module, loader):
22
 
    suite, _ = tests.permute_tests_for_extension(standard_tests, loader,
23
 
        'bzrlib.util._bencode_py', 'bzrlib._bencode_pyx')
 
22
    # parameterize all tests in this module
 
23
    suite = loader.suiteClass()
 
24
    import bzrlib.util._bencode_py as py_module
 
25
    scenarios = [('python', {'bencode': py_module})]
 
26
    if CompiledBencodeFeature.available():
 
27
        import bzrlib._bencode_pyx as c_module
 
28
        scenarios.append(('C', {'bencode': c_module}))
 
29
    else:
 
30
        # the compiled module isn't available, so we add a failing test
 
31
        class FailWithoutFeature(tests.TestCase):
 
32
            def test_fail(self):
 
33
                self.requireFeature(CompiledBencodeFeature)
 
34
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
 
35
    tests.multiply_tests(standard_tests, scenarios, suite)
24
36
    return suite
25
37
 
26
38
 
 
39
class _CompiledBencodeFeature(tests.Feature):
 
40
 
 
41
    def _probe(self):
 
42
        try:
 
43
            import bzrlib._bencode_pyx
 
44
        except ImportError:
 
45
            return False
 
46
        return True
 
47
 
 
48
    def feature_name(self):
 
49
        return 'bzrlib._bencode_pyx'
 
50
 
 
51
CompiledBencodeFeature = _CompiledBencodeFeature()
 
52
 
 
53
 
27
54
class TestBencodeDecode(tests.TestCase):
28
55
 
29
 
    module = None
 
56
    bencode = None
30
57
 
31
58
    def _check(self, expected, source):
32
 
        self.assertEquals(expected, self.module.bdecode(source))
 
59
        self.assertEquals(expected, self.bencode.bdecode(source))
33
60
 
34
61
    def _run_check_error(self, exc, bad):
35
62
        """Check that bdecoding a string raises a particular exception."""
36
 
        self.assertRaises(exc, self.module.bdecode, bad)
 
63
        self.assertRaises(exc, self.bencode.bdecode, bad)
37
64
 
38
65
    def test_int(self):
39
66
        self._check(0, 'i0e')
64
91
        self._check('1234567890', '10:1234567890')
65
92
 
66
93
    def test_large_string(self):
67
 
        self.assertRaises(ValueError, self.module.bdecode, "2147483639:foo")
 
94
        self.assertRaises(ValueError, self.bencode.bdecode, "2147483639:foo")
68
95
 
69
96
    def test_malformed_string(self):
70
97
        self._run_check_error(ValueError, '10:x')
119
146
        self._run_check_error(ValueError, 'd432432432432432432:e')
120
147
 
121
148
    def test_empty_string(self):
122
 
        self.assertRaises(ValueError, self.module.bdecode, '')
 
149
        self.assertRaises(ValueError, self.bencode.bdecode, '')
123
150
 
124
151
    def test_junk(self):
125
152
        self._run_check_error(ValueError, 'i6easd')
128
155
        self._run_check_error(ValueError, 'leanfdldjfh')
129
156
 
130
157
    def test_unknown_object(self):
131
 
        self.assertRaises(ValueError, self.module.bdecode, 'relwjhrlewjh')
 
158
        self.assertRaises(ValueError, self.bencode.bdecode, 'relwjhrlewjh')
132
159
 
133
160
    def test_unsupported_type(self):
134
161
        self._run_check_error(TypeError, float(1.5))
138
165
        self._run_check_error(TypeError, u"ie")
139
166
 
140
167
    def test_decoder_type_error(self):
141
 
        self.assertRaises(TypeError, self.module.bdecode, 1)
 
168
        self.assertRaises(TypeError, self.bencode.bdecode, 1)
142
169
 
143
170
 
144
171
class TestBencodeEncode(tests.TestCase):
145
172
 
146
 
    module = None
 
173
    bencode = None
147
174
 
148
175
    def _check(self, expected, source):
149
 
        self.assertEquals(expected, self.module.bencode(source))
 
176
        self.assertEquals(expected, self.bencode.bencode(source))
150
177
 
151
178
    def test_int(self):
152
179
        self._check('i4e', 4)
178
205
        for i in range(10000):
179
206
            l.append([])
180
207
            l = l[0]
181
 
        self.assertRaises(RuntimeError, self.module.bencode, 
 
208
        self.assertRaises(RuntimeError, self.bencode.bencode, 
182
209
            top)
183
210
 
184
211
    def test_dict(self):
193
220
        for i in range(10000):
194
221
            d[''] = {}
195
222
            d = d['']
196
 
        self.assertRaises(RuntimeError, self.module.bencode, 
 
223
        self.assertRaises(RuntimeError, self.bencode.bencode, 
197
224
            top)
198
225
 
199
226
    def test_bencached(self):
200
 
        self._check('i3e', self.module.Bencached(self.module.bencode(3)))
 
227
        self._check('i3e', self.bencode.Bencached(self.bencode.bencode(3)))
201
228
 
202
229
    def test_invalid_dict(self):
203
 
        self.assertRaises(TypeError, self.module.bencode, {1:"foo"})
 
230
        self.assertRaises(TypeError, self.bencode.bencode, {1:"foo"})
204
231
 
205
232
    def test_bool(self):
206
233
        self._check('i1e', True)