##// END OF EJS Templates
Add test for custom exception hook.
Thomas Kluyver -
Show More
@@ -1,374 +1,389 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Tests for the key interactiveshell module.
2 """Tests for the key interactiveshell module.
3
3
4 Historically the main classes in interactiveshell have been under-tested. This
4 Historically the main classes in interactiveshell have been under-tested. This
5 module should grow as many single-method tests as possible to trap many of the
5 module should grow as many single-method tests as possible to trap many of the
6 recurring bugs we seem to encounter with high-level interaction.
6 recurring bugs we seem to encounter with high-level interaction.
7
7
8 Authors
8 Authors
9 -------
9 -------
10 * Fernando Perez
10 * Fernando Perez
11 """
11 """
12 #-----------------------------------------------------------------------------
12 #-----------------------------------------------------------------------------
13 # Copyright (C) 2011 The IPython Development Team
13 # Copyright (C) 2011 The IPython Development Team
14 #
14 #
15 # Distributed under the terms of the BSD License. The full license is in
15 # Distributed under the terms of the BSD License. The full license is in
16 # the file COPYING, distributed as part of this software.
16 # the file COPYING, distributed as part of this software.
17 #-----------------------------------------------------------------------------
17 #-----------------------------------------------------------------------------
18
18
19 #-----------------------------------------------------------------------------
19 #-----------------------------------------------------------------------------
20 # Imports
20 # Imports
21 #-----------------------------------------------------------------------------
21 #-----------------------------------------------------------------------------
22 # stdlib
22 # stdlib
23 import os
23 import os
24 import shutil
24 import shutil
25 import sys
25 import sys
26 import tempfile
26 import tempfile
27 import unittest
27 import unittest
28 from os.path import join
28 from os.path import join
29 from StringIO import StringIO
29 from StringIO import StringIO
30
30
31 # third-party
31 # third-party
32 import nose.tools as nt
32 import nose.tools as nt
33
33
34 # Our own
34 # Our own
35 from IPython.testing.decorators import skipif
35 from IPython.testing.decorators import skipif
36 from IPython.utils import io
36 from IPython.utils import io
37
37
38 #-----------------------------------------------------------------------------
38 #-----------------------------------------------------------------------------
39 # Globals
39 # Globals
40 #-----------------------------------------------------------------------------
40 #-----------------------------------------------------------------------------
41 # This is used by every single test, no point repeating it ad nauseam
41 # This is used by every single test, no point repeating it ad nauseam
42 ip = get_ipython()
42 ip = get_ipython()
43
43
44 #-----------------------------------------------------------------------------
44 #-----------------------------------------------------------------------------
45 # Tests
45 # Tests
46 #-----------------------------------------------------------------------------
46 #-----------------------------------------------------------------------------
47
47
48 class InteractiveShellTestCase(unittest.TestCase):
48 class InteractiveShellTestCase(unittest.TestCase):
49 def test_naked_string_cells(self):
49 def test_naked_string_cells(self):
50 """Test that cells with only naked strings are fully executed"""
50 """Test that cells with only naked strings are fully executed"""
51 # First, single-line inputs
51 # First, single-line inputs
52 ip.run_cell('"a"\n')
52 ip.run_cell('"a"\n')
53 self.assertEquals(ip.user_ns['_'], 'a')
53 self.assertEquals(ip.user_ns['_'], 'a')
54 # And also multi-line cells
54 # And also multi-line cells
55 ip.run_cell('"""a\nb"""\n')
55 ip.run_cell('"""a\nb"""\n')
56 self.assertEquals(ip.user_ns['_'], 'a\nb')
56 self.assertEquals(ip.user_ns['_'], 'a\nb')
57
57
58 def test_run_empty_cell(self):
58 def test_run_empty_cell(self):
59 """Just make sure we don't get a horrible error with a blank
59 """Just make sure we don't get a horrible error with a blank
60 cell of input. Yes, I did overlook that."""
60 cell of input. Yes, I did overlook that."""
61 old_xc = ip.execution_count
61 old_xc = ip.execution_count
62 ip.run_cell('')
62 ip.run_cell('')
63 self.assertEquals(ip.execution_count, old_xc)
63 self.assertEquals(ip.execution_count, old_xc)
64
64
65 def test_run_cell_multiline(self):
65 def test_run_cell_multiline(self):
66 """Multi-block, multi-line cells must execute correctly.
66 """Multi-block, multi-line cells must execute correctly.
67 """
67 """
68 src = '\n'.join(["x=1",
68 src = '\n'.join(["x=1",
69 "y=2",
69 "y=2",
70 "if 1:",
70 "if 1:",
71 " x += 1",
71 " x += 1",
72 " y += 1",])
72 " y += 1",])
73 ip.run_cell(src)
73 ip.run_cell(src)
74 self.assertEquals(ip.user_ns['x'], 2)
74 self.assertEquals(ip.user_ns['x'], 2)
75 self.assertEquals(ip.user_ns['y'], 3)
75 self.assertEquals(ip.user_ns['y'], 3)
76
76
77 def test_multiline_string_cells(self):
77 def test_multiline_string_cells(self):
78 "Code sprinkled with multiline strings should execute (GH-306)"
78 "Code sprinkled with multiline strings should execute (GH-306)"
79 ip.run_cell('tmp=0')
79 ip.run_cell('tmp=0')
80 self.assertEquals(ip.user_ns['tmp'], 0)
80 self.assertEquals(ip.user_ns['tmp'], 0)
81 ip.run_cell('tmp=1;"""a\nb"""\n')
81 ip.run_cell('tmp=1;"""a\nb"""\n')
82 self.assertEquals(ip.user_ns['tmp'], 1)
82 self.assertEquals(ip.user_ns['tmp'], 1)
83
83
84 def test_dont_cache_with_semicolon(self):
84 def test_dont_cache_with_semicolon(self):
85 "Ending a line with semicolon should not cache the returned object (GH-307)"
85 "Ending a line with semicolon should not cache the returned object (GH-307)"
86 oldlen = len(ip.user_ns['Out'])
86 oldlen = len(ip.user_ns['Out'])
87 a = ip.run_cell('1;', store_history=True)
87 a = ip.run_cell('1;', store_history=True)
88 newlen = len(ip.user_ns['Out'])
88 newlen = len(ip.user_ns['Out'])
89 self.assertEquals(oldlen, newlen)
89 self.assertEquals(oldlen, newlen)
90 #also test the default caching behavior
90 #also test the default caching behavior
91 ip.run_cell('1', store_history=True)
91 ip.run_cell('1', store_history=True)
92 newlen = len(ip.user_ns['Out'])
92 newlen = len(ip.user_ns['Out'])
93 self.assertEquals(oldlen+1, newlen)
93 self.assertEquals(oldlen+1, newlen)
94
94
95 def test_In_variable(self):
95 def test_In_variable(self):
96 "Verify that In variable grows with user input (GH-284)"
96 "Verify that In variable grows with user input (GH-284)"
97 oldlen = len(ip.user_ns['In'])
97 oldlen = len(ip.user_ns['In'])
98 ip.run_cell('1;', store_history=True)
98 ip.run_cell('1;', store_history=True)
99 newlen = len(ip.user_ns['In'])
99 newlen = len(ip.user_ns['In'])
100 self.assertEquals(oldlen+1, newlen)
100 self.assertEquals(oldlen+1, newlen)
101 self.assertEquals(ip.user_ns['In'][-1],'1;')
101 self.assertEquals(ip.user_ns['In'][-1],'1;')
102
102
103 def test_magic_names_in_string(self):
103 def test_magic_names_in_string(self):
104 ip.run_cell('a = """\n%exit\n"""')
104 ip.run_cell('a = """\n%exit\n"""')
105 self.assertEquals(ip.user_ns['a'], '\n%exit\n')
105 self.assertEquals(ip.user_ns['a'], '\n%exit\n')
106
106
107 def test_alias_crash(self):
107 def test_alias_crash(self):
108 """Errors in prefilter can't crash IPython"""
108 """Errors in prefilter can't crash IPython"""
109 ip.run_cell('%alias parts echo first %s second %s')
109 ip.run_cell('%alias parts echo first %s second %s')
110 # capture stderr:
110 # capture stderr:
111 save_err = io.stderr
111 save_err = io.stderr
112 io.stderr = StringIO()
112 io.stderr = StringIO()
113 ip.run_cell('parts 1')
113 ip.run_cell('parts 1')
114 err = io.stderr.getvalue()
114 err = io.stderr.getvalue()
115 io.stderr = save_err
115 io.stderr = save_err
116 self.assertEquals(err.split(':')[0], 'ERROR')
116 self.assertEquals(err.split(':')[0], 'ERROR')
117
117
118 def test_trailing_newline(self):
118 def test_trailing_newline(self):
119 """test that running !(command) does not raise a SyntaxError"""
119 """test that running !(command) does not raise a SyntaxError"""
120 ip.run_cell('!(true)\n', False)
120 ip.run_cell('!(true)\n', False)
121 ip.run_cell('!(true)\n\n\n', False)
121 ip.run_cell('!(true)\n\n\n', False)
122
122
123 def test_gh_597(self):
123 def test_gh_597(self):
124 """Pretty-printing lists of objects with non-ascii reprs may cause
124 """Pretty-printing lists of objects with non-ascii reprs may cause
125 problems."""
125 problems."""
126 class Spam(object):
126 class Spam(object):
127 def __repr__(self):
127 def __repr__(self):
128 return "\xe9"*50
128 return "\xe9"*50
129 import IPython.core.formatters
129 import IPython.core.formatters
130 f = IPython.core.formatters.PlainTextFormatter()
130 f = IPython.core.formatters.PlainTextFormatter()
131 f([Spam(),Spam()])
131 f([Spam(),Spam()])
132
132
133
133
134 def test_future_flags(self):
134 def test_future_flags(self):
135 """Check that future flags are used for parsing code (gh-777)"""
135 """Check that future flags are used for parsing code (gh-777)"""
136 ip.run_cell('from __future__ import print_function')
136 ip.run_cell('from __future__ import print_function')
137 try:
137 try:
138 ip.run_cell('prfunc_return_val = print(1,2, sep=" ")')
138 ip.run_cell('prfunc_return_val = print(1,2, sep=" ")')
139 assert 'prfunc_return_val' in ip.user_ns
139 assert 'prfunc_return_val' in ip.user_ns
140 finally:
140 finally:
141 # Reset compiler flags so we don't mess up other tests.
141 # Reset compiler flags so we don't mess up other tests.
142 ip.compile.reset_compiler_flags()
142 ip.compile.reset_compiler_flags()
143
143
144 def test_future_unicode(self):
144 def test_future_unicode(self):
145 """Check that unicode_literals is imported from __future__ (gh #786)"""
145 """Check that unicode_literals is imported from __future__ (gh #786)"""
146 try:
146 try:
147 ip.run_cell(u'byte_str = "a"')
147 ip.run_cell(u'byte_str = "a"')
148 assert isinstance(ip.user_ns['byte_str'], str) # string literals are byte strings by default
148 assert isinstance(ip.user_ns['byte_str'], str) # string literals are byte strings by default
149 ip.run_cell('from __future__ import unicode_literals')
149 ip.run_cell('from __future__ import unicode_literals')
150 ip.run_cell(u'unicode_str = "a"')
150 ip.run_cell(u'unicode_str = "a"')
151 assert isinstance(ip.user_ns['unicode_str'], unicode) # strings literals are now unicode
151 assert isinstance(ip.user_ns['unicode_str'], unicode) # strings literals are now unicode
152 finally:
152 finally:
153 # Reset compiler flags so we don't mess up other tests.
153 # Reset compiler flags so we don't mess up other tests.
154 ip.compile.reset_compiler_flags()
154 ip.compile.reset_compiler_flags()
155
155
156 def test_can_pickle(self):
156 def test_can_pickle(self):
157 "Can we pickle objects defined interactively (GH-29)"
157 "Can we pickle objects defined interactively (GH-29)"
158 ip = get_ipython()
158 ip = get_ipython()
159 ip.reset()
159 ip.reset()
160 ip.run_cell(("class Mylist(list):\n"
160 ip.run_cell(("class Mylist(list):\n"
161 " def __init__(self,x=[]):\n"
161 " def __init__(self,x=[]):\n"
162 " list.__init__(self,x)"))
162 " list.__init__(self,x)"))
163 ip.run_cell("w=Mylist([1,2,3])")
163 ip.run_cell("w=Mylist([1,2,3])")
164
164
165 from cPickle import dumps
165 from cPickle import dumps
166
166
167 # We need to swap in our main module - this is only necessary
167 # We need to swap in our main module - this is only necessary
168 # inside the test framework, because IPython puts the interactive module
168 # inside the test framework, because IPython puts the interactive module
169 # in place (but the test framework undoes this).
169 # in place (but the test framework undoes this).
170 _main = sys.modules['__main__']
170 _main = sys.modules['__main__']
171 sys.modules['__main__'] = ip.user_module
171 sys.modules['__main__'] = ip.user_module
172 try:
172 try:
173 res = dumps(ip.user_ns["w"])
173 res = dumps(ip.user_ns["w"])
174 finally:
174 finally:
175 sys.modules['__main__'] = _main
175 sys.modules['__main__'] = _main
176 self.assertTrue(isinstance(res, bytes))
176 self.assertTrue(isinstance(res, bytes))
177
177
178 def test_global_ns(self):
178 def test_global_ns(self):
179 "Code in functions must be able to access variables outside them."
179 "Code in functions must be able to access variables outside them."
180 ip = get_ipython()
180 ip = get_ipython()
181 ip.run_cell("a = 10")
181 ip.run_cell("a = 10")
182 ip.run_cell(("def f(x):\n"
182 ip.run_cell(("def f(x):\n"
183 " return x + a"))
183 " return x + a"))
184 ip.run_cell("b = f(12)")
184 ip.run_cell("b = f(12)")
185 self.assertEqual(ip.user_ns["b"], 22)
185 self.assertEqual(ip.user_ns["b"], 22)
186
186
187 def test_bad_custom_tb(self):
187 def test_bad_custom_tb(self):
188 """Check that InteractiveShell is protected from bad custom exception handlers"""
188 """Check that InteractiveShell is protected from bad custom exception handlers"""
189 from IPython.utils import io
189 from IPython.utils import io
190 save_stderr = io.stderr
190 save_stderr = io.stderr
191 try:
191 try:
192 # capture stderr
192 # capture stderr
193 io.stderr = StringIO()
193 io.stderr = StringIO()
194 ip.set_custom_exc((IOError,), lambda etype,value,tb: 1/0)
194 ip.set_custom_exc((IOError,), lambda etype,value,tb: 1/0)
195 self.assertEquals(ip.custom_exceptions, (IOError,))
195 self.assertEquals(ip.custom_exceptions, (IOError,))
196 ip.run_cell(u'raise IOError("foo")')
196 ip.run_cell(u'raise IOError("foo")')
197 self.assertEquals(ip.custom_exceptions, ())
197 self.assertEquals(ip.custom_exceptions, ())
198 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
198 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
199 finally:
199 finally:
200 io.stderr = save_stderr
200 io.stderr = save_stderr
201
201
202 def test_bad_custom_tb_return(self):
202 def test_bad_custom_tb_return(self):
203 """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
203 """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
204 from IPython.utils import io
204 from IPython.utils import io
205 save_stderr = io.stderr
205 save_stderr = io.stderr
206 try:
206 try:
207 # capture stderr
207 # capture stderr
208 io.stderr = StringIO()
208 io.stderr = StringIO()
209 ip.set_custom_exc((NameError,),lambda etype,value,tb, tb_offset=None: 1)
209 ip.set_custom_exc((NameError,),lambda etype,value,tb, tb_offset=None: 1)
210 self.assertEquals(ip.custom_exceptions, (NameError,))
210 self.assertEquals(ip.custom_exceptions, (NameError,))
211 ip.run_cell(u'a=abracadabra')
211 ip.run_cell(u'a=abracadabra')
212 self.assertEquals(ip.custom_exceptions, ())
212 self.assertEquals(ip.custom_exceptions, ())
213 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
213 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
214 finally:
214 finally:
215 io.stderr = save_stderr
215 io.stderr = save_stderr
216
216
217 def test_drop_by_id(self):
217 def test_drop_by_id(self):
218 myvars = {"a":object(), "b":object(), "c": object()}
218 myvars = {"a":object(), "b":object(), "c": object()}
219 ip.push(myvars, interactive=False)
219 ip.push(myvars, interactive=False)
220 for name in myvars:
220 for name in myvars:
221 assert name in ip.user_ns, name
221 assert name in ip.user_ns, name
222 assert name in ip.user_ns_hidden, name
222 assert name in ip.user_ns_hidden, name
223 ip.user_ns['b'] = 12
223 ip.user_ns['b'] = 12
224 ip.drop_by_id(myvars)
224 ip.drop_by_id(myvars)
225 for name in ["a", "c"]:
225 for name in ["a", "c"]:
226 assert name not in ip.user_ns, name
226 assert name not in ip.user_ns, name
227 assert name not in ip.user_ns_hidden, name
227 assert name not in ip.user_ns_hidden, name
228 assert ip.user_ns['b'] == 12
228 assert ip.user_ns['b'] == 12
229 ip.reset()
229 ip.reset()
230
230
231 def test_var_expand(self):
231 def test_var_expand(self):
232 ip.user_ns['f'] = u'Ca\xf1o'
232 ip.user_ns['f'] = u'Ca\xf1o'
233 self.assertEqual(ip.var_expand(u'echo $f'), u'echo Ca\xf1o')
233 self.assertEqual(ip.var_expand(u'echo $f'), u'echo Ca\xf1o')
234 self.assertEqual(ip.var_expand(u'echo {f}'), u'echo Ca\xf1o')
234 self.assertEqual(ip.var_expand(u'echo {f}'), u'echo Ca\xf1o')
235 self.assertEqual(ip.var_expand(u'echo {f[:-1]}'), u'echo Ca\xf1')
235 self.assertEqual(ip.var_expand(u'echo {f[:-1]}'), u'echo Ca\xf1')
236 self.assertEqual(ip.var_expand(u'echo {1*2}'), u'echo 2')
236 self.assertEqual(ip.var_expand(u'echo {1*2}'), u'echo 2')
237
237
238 ip.user_ns['f'] = b'Ca\xc3\xb1o'
238 ip.user_ns['f'] = b'Ca\xc3\xb1o'
239 # This should not raise any exception:
239 # This should not raise any exception:
240 ip.var_expand(u'echo $f')
240 ip.var_expand(u'echo $f')
241
241
242 def test_bad_var_expand(self):
242 def test_bad_var_expand(self):
243 """var_expand on invalid formats shouldn't raise"""
243 """var_expand on invalid formats shouldn't raise"""
244 # SyntaxError
244 # SyntaxError
245 self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
245 self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
246 # NameError
246 # NameError
247 self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
247 self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
248 # ZeroDivisionError
248 # ZeroDivisionError
249 self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
249 self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
250
250
251 def test_silent_nopostexec(self):
251 def test_silent_nopostexec(self):
252 """run_cell(silent=True) doesn't invoke post-exec funcs"""
252 """run_cell(silent=True) doesn't invoke post-exec funcs"""
253 d = dict(called=False)
253 d = dict(called=False)
254 def set_called():
254 def set_called():
255 d['called'] = True
255 d['called'] = True
256
256
257 ip.register_post_execute(set_called)
257 ip.register_post_execute(set_called)
258 ip.run_cell("1", silent=True)
258 ip.run_cell("1", silent=True)
259 self.assertFalse(d['called'])
259 self.assertFalse(d['called'])
260 # double-check that non-silent exec did what we expected
260 # double-check that non-silent exec did what we expected
261 # silent to avoid
261 # silent to avoid
262 ip.run_cell("1")
262 ip.run_cell("1")
263 self.assertTrue(d['called'])
263 self.assertTrue(d['called'])
264 # remove post-exec
264 # remove post-exec
265 ip._post_execute.pop(set_called)
265 ip._post_execute.pop(set_called)
266
266
267 def test_silent_noadvance(self):
267 def test_silent_noadvance(self):
268 """run_cell(silent=True) doesn't advance execution_count"""
268 """run_cell(silent=True) doesn't advance execution_count"""
269 ec = ip.execution_count
269 ec = ip.execution_count
270 # silent should force store_history=False
270 # silent should force store_history=False
271 ip.run_cell("1", store_history=True, silent=True)
271 ip.run_cell("1", store_history=True, silent=True)
272
272
273 self.assertEquals(ec, ip.execution_count)
273 self.assertEquals(ec, ip.execution_count)
274 # double-check that non-silent exec did what we expected
274 # double-check that non-silent exec did what we expected
275 # silent to avoid
275 # silent to avoid
276 ip.run_cell("1", store_history=True)
276 ip.run_cell("1", store_history=True)
277 self.assertEquals(ec+1, ip.execution_count)
277 self.assertEquals(ec+1, ip.execution_count)
278
278
279 def test_silent_nodisplayhook(self):
279 def test_silent_nodisplayhook(self):
280 """run_cell(silent=True) doesn't trigger displayhook"""
280 """run_cell(silent=True) doesn't trigger displayhook"""
281 d = dict(called=False)
281 d = dict(called=False)
282
282
283 trap = ip.display_trap
283 trap = ip.display_trap
284 save_hook = trap.hook
284 save_hook = trap.hook
285
285
286 def failing_hook(*args, **kwargs):
286 def failing_hook(*args, **kwargs):
287 d['called'] = True
287 d['called'] = True
288
288
289 try:
289 try:
290 trap.hook = failing_hook
290 trap.hook = failing_hook
291 ip.run_cell("1", silent=True)
291 ip.run_cell("1", silent=True)
292 self.assertFalse(d['called'])
292 self.assertFalse(d['called'])
293 # double-check that non-silent exec did what we expected
293 # double-check that non-silent exec did what we expected
294 # silent to avoid
294 # silent to avoid
295 ip.run_cell("1")
295 ip.run_cell("1")
296 self.assertTrue(d['called'])
296 self.assertTrue(d['called'])
297 finally:
297 finally:
298 trap.hook = save_hook
298 trap.hook = save_hook
299
299
300 @skipif(sys.version_info[0] >= 3, "softspace removed in py3")
300 @skipif(sys.version_info[0] >= 3, "softspace removed in py3")
301 def test_print_softspace(self):
301 def test_print_softspace(self):
302 """Verify that softspace is handled correctly when executing multiple
302 """Verify that softspace is handled correctly when executing multiple
303 statements.
303 statements.
304
304
305 In [1]: print 1; print 2
305 In [1]: print 1; print 2
306 1
306 1
307 2
307 2
308
308
309 In [2]: print 1,; print 2
309 In [2]: print 1,; print 2
310 1 2
310 1 2
311 """
311 """
312
312
313 def test_ofind_line_magic(self):
313 def test_ofind_line_magic(self):
314 from IPython.core.magic import register_line_magic
314 from IPython.core.magic import register_line_magic
315
315
316 @register_line_magic
316 @register_line_magic
317 def lmagic(line):
317 def lmagic(line):
318 "A line magic"
318 "A line magic"
319
319
320 # Get info on line magic
320 # Get info on line magic
321 lfind = ip._ofind('lmagic')
321 lfind = ip._ofind('lmagic')
322 info = dict(found=True, isalias=False, ismagic=True,
322 info = dict(found=True, isalias=False, ismagic=True,
323 namespace = 'IPython internal', obj= lmagic.__wrapped__,
323 namespace = 'IPython internal', obj= lmagic.__wrapped__,
324 parent = None)
324 parent = None)
325 nt.assert_equal(lfind, info)
325 nt.assert_equal(lfind, info)
326
326
327 def test_ofind_cell_magic(self):
327 def test_ofind_cell_magic(self):
328 from IPython.core.magic import register_cell_magic
328 from IPython.core.magic import register_cell_magic
329
329
330 @register_cell_magic
330 @register_cell_magic
331 def cmagic(line, cell):
331 def cmagic(line, cell):
332 "A cell magic"
332 "A cell magic"
333
333
334 # Get info on cell magic
334 # Get info on cell magic
335 find = ip._ofind('cmagic')
335 find = ip._ofind('cmagic')
336 info = dict(found=True, isalias=False, ismagic=True,
336 info = dict(found=True, isalias=False, ismagic=True,
337 namespace = 'IPython internal', obj= cmagic.__wrapped__,
337 namespace = 'IPython internal', obj= cmagic.__wrapped__,
338 parent = None)
338 parent = None)
339 nt.assert_equal(find, info)
339 nt.assert_equal(find, info)
340
341 def test_custom_exception(self):
342 called = []
343 def my_handler(shell, etype, value, tb, tb_offset=None):
344 called.append(etype)
345 shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
346
347 ip.set_custom_exc((ValueError,), my_handler)
348 try:
349 ip.run_cell("raise ValueError('test')")
350 # Check that this was called, and only once.
351 self.assertEqual(called, [ValueError])
352 finally:
353 # Reset the custom exception hook
354 ip.set_custom_exc((), None)
340
355
341
356
342 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
357 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
343
358
344 def setUp(self):
359 def setUp(self):
345 self.BASETESTDIR = tempfile.mkdtemp()
360 self.BASETESTDIR = tempfile.mkdtemp()
346 self.TESTDIR = join(self.BASETESTDIR, u"åäö")
361 self.TESTDIR = join(self.BASETESTDIR, u"åäö")
347 os.mkdir(self.TESTDIR)
362 os.mkdir(self.TESTDIR)
348 with open(join(self.TESTDIR, u"åäötestscript.py"), "w") as sfile:
363 with open(join(self.TESTDIR, u"åäötestscript.py"), "w") as sfile:
349 sfile.write("pass\n")
364 sfile.write("pass\n")
350 self.oldpath = os.getcwdu()
365 self.oldpath = os.getcwdu()
351 os.chdir(self.TESTDIR)
366 os.chdir(self.TESTDIR)
352 self.fname = u"åäötestscript.py"
367 self.fname = u"åäötestscript.py"
353
368
354 def tearDown(self):
369 def tearDown(self):
355 os.chdir(self.oldpath)
370 os.chdir(self.oldpath)
356 shutil.rmtree(self.BASETESTDIR)
371 shutil.rmtree(self.BASETESTDIR)
357
372
358 def test_1(self):
373 def test_1(self):
359 """Test safe_execfile with non-ascii path
374 """Test safe_execfile with non-ascii path
360 """
375 """
361 ip.safe_execfile(self.fname, {}, raise_exceptions=True)
376 ip.safe_execfile(self.fname, {}, raise_exceptions=True)
362
377
363
378
364 class TestSystemRaw(unittest.TestCase):
379 class TestSystemRaw(unittest.TestCase):
365 def test_1(self):
380 def test_1(self):
366 """Test system_raw with non-ascii cmd
381 """Test system_raw with non-ascii cmd
367 """
382 """
368 cmd = ur'''python -c "'åäö'" '''
383 cmd = ur'''python -c "'åäö'" '''
369 ip.system_raw(cmd)
384 ip.system_raw(cmd)
370
385
371
386
372 def test__IPYTHON__():
387 def test__IPYTHON__():
373 # This shouldn't raise a NameError, that's all
388 # This shouldn't raise a NameError, that's all
374 __IPYTHON__
389 __IPYTHON__
General Comments 0
You need to be logged in to leave comments. Login now