← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_bencode.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-11-17 03:20:35 UTC
  • mfrom: (4792.4.3 456036)
  • Revision ID: pqm@pqm.ubuntu.com-20091117032035-s3sgtlixj1lrminn
(Gordon Tyler) Fix IndexError during 'bzr ignore /' (#456036)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bencode.py
1
 
# Copyright (C) 2007, 2009 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)