|
1 import unittest |
|
2 import __builtin__ |
|
3 import exceptions |
|
4 import warnings |
|
5 from test.test_support import run_unittest |
|
6 import os |
|
7 from platform import system as platform_system |
|
8 |
|
9 def ignore_message_warning(): |
|
10 """Ignore the DeprecationWarning for BaseException.message.""" |
|
11 warnings.resetwarnings() |
|
12 warnings.filterwarnings("ignore", "BaseException.message", |
|
13 DeprecationWarning) |
|
14 |
|
15 |
|
16 class ExceptionClassTests(unittest.TestCase): |
|
17 |
|
18 """Tests for anything relating to exception objects themselves (e.g., |
|
19 inheritance hierarchy)""" |
|
20 |
|
21 def test_builtins_new_style(self): |
|
22 self.failUnless(issubclass(Exception, object)) |
|
23 |
|
24 def verify_instance_interface(self, ins): |
|
25 with warnings.catch_warnings(): |
|
26 ignore_message_warning() |
|
27 for attr in ("args", "message", "__str__", "__repr__", |
|
28 "__getitem__"): |
|
29 self.failUnless(hasattr(ins, attr), |
|
30 "%s missing %s attribute" % |
|
31 (ins.__class__.__name__, attr)) |
|
32 |
|
33 def test_inheritance(self): |
|
34 # Make sure the inheritance hierarchy matches the documentation |
|
35 exc_set = set(x for x in dir(exceptions) if not x.startswith('_')) |
|
36 inheritance_tree = open(os.path.join(os.path.split(__file__)[0], |
|
37 'exception_hierarchy.txt')) |
|
38 try: |
|
39 superclass_name = inheritance_tree.readline().rstrip() |
|
40 try: |
|
41 last_exc = getattr(__builtin__, superclass_name) |
|
42 except AttributeError: |
|
43 self.fail("base class %s not a built-in" % superclass_name) |
|
44 self.failUnless(superclass_name in exc_set) |
|
45 exc_set.discard(superclass_name) |
|
46 superclasses = [] # Loop will insert base exception |
|
47 last_depth = 0 |
|
48 for exc_line in inheritance_tree: |
|
49 exc_line = exc_line.rstrip() |
|
50 depth = exc_line.rindex('-') |
|
51 exc_name = exc_line[depth+2:] # Slice past space |
|
52 if '(' in exc_name: |
|
53 paren_index = exc_name.index('(') |
|
54 platform_name = exc_name[paren_index+1:-1] |
|
55 exc_name = exc_name[:paren_index-1] # Slice off space |
|
56 if platform_system() != platform_name: |
|
57 exc_set.discard(exc_name) |
|
58 continue |
|
59 if '[' in exc_name: |
|
60 left_bracket = exc_name.index('[') |
|
61 exc_name = exc_name[:left_bracket-1] # cover space |
|
62 try: |
|
63 exc = getattr(__builtin__, exc_name) |
|
64 except AttributeError: |
|
65 self.fail("%s not a built-in exception" % exc_name) |
|
66 if last_depth < depth: |
|
67 superclasses.append((last_depth, last_exc)) |
|
68 elif last_depth > depth: |
|
69 while superclasses[-1][0] >= depth: |
|
70 superclasses.pop() |
|
71 self.failUnless(issubclass(exc, superclasses[-1][1]), |
|
72 "%s is not a subclass of %s" % (exc.__name__, |
|
73 superclasses[-1][1].__name__)) |
|
74 try: # Some exceptions require arguments; just skip them |
|
75 self.verify_instance_interface(exc()) |
|
76 except TypeError: |
|
77 pass |
|
78 self.failUnless(exc_name in exc_set) |
|
79 exc_set.discard(exc_name) |
|
80 last_exc = exc |
|
81 last_depth = depth |
|
82 finally: |
|
83 inheritance_tree.close() |
|
84 self.failUnlessEqual(len(exc_set), 0, "%s not accounted for" % exc_set) |
|
85 |
|
86 interface_tests = ("length", "args", "message", "str", "unicode", "repr", |
|
87 "indexing") |
|
88 |
|
89 def interface_test_driver(self, results): |
|
90 for test_name, (given, expected) in zip(self.interface_tests, results): |
|
91 self.failUnlessEqual(given, expected, "%s: %s != %s" % (test_name, |
|
92 given, expected)) |
|
93 |
|
94 def test_interface_single_arg(self): |
|
95 # Make sure interface works properly when given a single argument |
|
96 arg = "spam" |
|
97 exc = Exception(arg) |
|
98 with warnings.catch_warnings(): |
|
99 ignore_message_warning() |
|
100 results = ([len(exc.args), 1], [exc.args[0], arg], |
|
101 [exc.message, arg], |
|
102 [str(exc), str(arg)], [unicode(exc), unicode(arg)], |
|
103 [repr(exc), exc.__class__.__name__ + repr(exc.args)], [exc[0], |
|
104 arg]) |
|
105 self.interface_test_driver(results) |
|
106 |
|
107 def test_interface_multi_arg(self): |
|
108 # Make sure interface correct when multiple arguments given |
|
109 arg_count = 3 |
|
110 args = tuple(range(arg_count)) |
|
111 exc = Exception(*args) |
|
112 with warnings.catch_warnings(): |
|
113 ignore_message_warning() |
|
114 results = ([len(exc.args), arg_count], [exc.args, args], |
|
115 [exc.message, ''], [str(exc), str(args)], |
|
116 [unicode(exc), unicode(args)], |
|
117 [repr(exc), exc.__class__.__name__ + repr(exc.args)], |
|
118 [exc[-1], args[-1]]) |
|
119 self.interface_test_driver(results) |
|
120 |
|
121 def test_interface_no_arg(self): |
|
122 # Make sure that with no args that interface is correct |
|
123 exc = Exception() |
|
124 with warnings.catch_warnings(): |
|
125 ignore_message_warning() |
|
126 results = ([len(exc.args), 0], [exc.args, tuple()], |
|
127 [exc.message, ''], |
|
128 [str(exc), ''], [unicode(exc), u''], |
|
129 [repr(exc), exc.__class__.__name__ + '()'], [True, True]) |
|
130 self.interface_test_driver(results) |
|
131 |
|
132 |
|
133 def test_message_deprecation(self): |
|
134 # As of Python 2.6, BaseException.message is deprecated. |
|
135 with warnings.catch_warnings(): |
|
136 warnings.resetwarnings() |
|
137 warnings.filterwarnings('error') |
|
138 |
|
139 try: |
|
140 BaseException().message |
|
141 except DeprecationWarning: |
|
142 pass |
|
143 else: |
|
144 self.fail("BaseException.message not deprecated") |
|
145 |
|
146 exc = BaseException() |
|
147 try: |
|
148 exc.message = '' |
|
149 except DeprecationWarning: |
|
150 pass |
|
151 else: |
|
152 self.fail("BaseException.message assignment not deprecated") |
|
153 |
|
154 class UsageTests(unittest.TestCase): |
|
155 |
|
156 """Test usage of exceptions""" |
|
157 |
|
158 def raise_fails(self, object_): |
|
159 """Make sure that raising 'object_' triggers a TypeError.""" |
|
160 try: |
|
161 raise object_ |
|
162 except TypeError: |
|
163 return # What is expected. |
|
164 self.fail("TypeError expected for raising %s" % type(object_)) |
|
165 |
|
166 def catch_fails(self, object_): |
|
167 """Catching 'object_' should raise a TypeError.""" |
|
168 try: |
|
169 try: |
|
170 raise StandardError |
|
171 except object_: |
|
172 pass |
|
173 except TypeError: |
|
174 pass |
|
175 except StandardError: |
|
176 self.fail("TypeError expected when catching %s" % type(object_)) |
|
177 |
|
178 try: |
|
179 try: |
|
180 raise StandardError |
|
181 except (object_,): |
|
182 pass |
|
183 except TypeError: |
|
184 return |
|
185 except StandardError: |
|
186 self.fail("TypeError expected when catching %s as specified in a " |
|
187 "tuple" % type(object_)) |
|
188 |
|
189 def test_raise_classic(self): |
|
190 # Raising a classic class is okay (for now). |
|
191 class ClassicClass: |
|
192 pass |
|
193 try: |
|
194 raise ClassicClass |
|
195 except ClassicClass: |
|
196 pass |
|
197 except: |
|
198 self.fail("unable to raise classic class") |
|
199 try: |
|
200 raise ClassicClass() |
|
201 except ClassicClass: |
|
202 pass |
|
203 except: |
|
204 self.fail("unable to raise class class instance") |
|
205 |
|
206 def test_raise_new_style_non_exception(self): |
|
207 # You cannot raise a new-style class that does not inherit from |
|
208 # BaseException; the ability was not possible until BaseException's |
|
209 # introduction so no need to support new-style objects that do not |
|
210 # inherit from it. |
|
211 class NewStyleClass(object): |
|
212 pass |
|
213 self.raise_fails(NewStyleClass) |
|
214 self.raise_fails(NewStyleClass()) |
|
215 |
|
216 def test_raise_string(self): |
|
217 # Raising a string raises TypeError. |
|
218 self.raise_fails("spam") |
|
219 |
|
220 def test_catch_string(self): |
|
221 # Catching a string should trigger a DeprecationWarning. |
|
222 with warnings.catch_warnings(): |
|
223 warnings.resetwarnings() |
|
224 warnings.filterwarnings("error") |
|
225 str_exc = "spam" |
|
226 try: |
|
227 try: |
|
228 raise StandardError |
|
229 except str_exc: |
|
230 pass |
|
231 except DeprecationWarning: |
|
232 pass |
|
233 except StandardError: |
|
234 self.fail("catching a string exception did not raise " |
|
235 "DeprecationWarning") |
|
236 # Make sure that even if the string exception is listed in a tuple |
|
237 # that a warning is raised. |
|
238 try: |
|
239 try: |
|
240 raise StandardError |
|
241 except (AssertionError, str_exc): |
|
242 pass |
|
243 except DeprecationWarning: |
|
244 pass |
|
245 except StandardError: |
|
246 self.fail("catching a string exception specified in a tuple did " |
|
247 "not raise DeprecationWarning") |
|
248 |
|
249 |
|
250 def test_main(): |
|
251 run_unittest(ExceptionClassTests, UsageTests) |
|
252 |
|
253 |
|
254 |
|
255 if __name__ == '__main__': |
|
256 test_main() |