← 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: Gordon Tyler
  • Date: 2010-01-14 15:24:04 UTC
  • mto: (5037.3.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5046.
  • Revision ID: gordon@doxxx.net-20100114152404-d64ik2afl96lcml0
Reverted changes to test_rules since the original should work now.

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 compiled_bencode_feature.available():
 
27
        scenarios.append(('C', {'bencode': compiled_bencode_feature.module}))
 
28
    else:
 
29
        # the compiled module isn't available, so we add a failing test
 
30
        class FailWithoutFeature(tests.TestCase):
 
31
            def test_fail(self):
 
32
                self.requireFeature(compiled_bencode_feature)
 
33
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
 
34
    tests.multiply_tests(standard_tests, scenarios, suite)
24
35
    return suite
25
36
 
26
37
 
 
38
compiled_bencode_feature = tests.ModuleAvailableFeature('bzrlib._bencode_pyx')
 
39
 
 
40
 
27
41
class TestBencodeDecode(tests.TestCase):
28
42
 
29
 
    module = None
 
43
    bencode = None
30
44
 
31
45
    def _check(self, expected, source):
32
 
        self.assertEquals(expected, self.module.bdecode(source))
 
46
        self.assertEquals(expected, self.bencode.bdecode(source))
33
47
 
34
48
    def _run_check_error(self, exc, bad):
35
49
        """Check that bdecoding a string raises a particular exception."""
36
 
        self.assertRaises(exc, self.module.bdecode, bad)
 
50
        self.assertRaises(exc, self.bencode.bdecode, bad)
37
51
 
38
52
    def test_int(self):
39
53
        self._check(0, 'i0e')
64
78
        self._check('1234567890', '10:1234567890')
65
79
 
66
80
    def test_large_string(self):
67
 
        self.assertRaises(ValueError, self.module.bdecode, "2147483639:foo")
 
81
        self.assertRaises(ValueError, self.bencode.bdecode, "2147483639:foo")
68
82
 
69
83
    def test_malformed_string(self):
70
84
        self._run_check_error(ValueError, '10:x')
119
133
        self._run_check_error(ValueError, 'd432432432432432432:e')
120
134
 
121
135
    def test_empty_string(self):
122
 
        self.assertRaises(ValueError, self.module.bdecode, '')
 
136
        self.assertRaises(ValueError, self.bencode.bdecode, '')
123
137
 
124
138
    def test_junk(self):
125
139
        self._run_check_error(ValueError, 'i6easd')
128
142
        self._run_check_error(ValueError, 'leanfdldjfh')
129
143
 
130
144
    def test_unknown_object(self):
131
 
        self.assertRaises(ValueError, self.module.bdecode, 'relwjhrlewjh')
 
145
        self.assertRaises(ValueError, self.bencode.bdecode, 'relwjhrlewjh')
132
146
 
133
147
    def test_unsupported_type(self):
134
148
        self._run_check_error(TypeError, float(1.5))
138
152
        self._run_check_error(TypeError, u"ie")
139
153
 
140
154
    def test_decoder_type_error(self):
141
 
        self.assertRaises(TypeError, self.module.bdecode, 1)
 
155
        self.assertRaises(TypeError, self.bencode.bdecode, 1)
142
156
 
143
157
 
144
158
class TestBencodeEncode(tests.TestCase):
145
159
 
146
 
    module = None
 
160
    bencode = None
147
161
 
148
162
    def _check(self, expected, source):
149
 
        self.assertEquals(expected, self.module.bencode(source))
 
163
        self.assertEquals(expected, self.bencode.bencode(source))
150
164
 
151
165
    def test_int(self):
152
166
        self._check('i4e', 4)
178
192
        for i in range(10000):
179
193
            l.append([])
180
194
            l = l[0]
181
 
        self.assertRaises(RuntimeError, self.module.bencode, 
 
195
        self.assertRaises(RuntimeError, self.bencode.bencode, 
182
196
            top)
183
197
 
184
198
    def test_dict(self):
193
207
        for i in range(10000):
194
208
            d[''] = {}
195
209
            d = d['']
196
 
        self.assertRaises(RuntimeError, self.module.bencode, 
 
210
        self.assertRaises(RuntimeError, self.bencode.bencode, 
197
211
            top)
198
212
 
199
213
    def test_bencached(self):
200
 
        self._check('i3e', self.module.Bencached(self.module.bencode(3)))
 
214
        self._check('i3e', self.bencode.Bencached(self.bencode.bencode(3)))
201
215
 
202
216
    def test_invalid_dict(self):
203
 
        self.assertRaises(TypeError, self.module.bencode, {1:"foo"})
 
217
        self.assertRaises(TypeError, self.bencode.bencode, {1:"foo"})
204
218
 
205
219
    def test_bool(self):
206
220
        self._check('i1e', True)