##// END OF EJS Templates
Add failing test for issue gh-1878
Thomas Kluyver -
Show More
@@ -1,389 +1,397 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_var_expand_local(self):
243 ip.run_cell('def test():\n'
244 ' lvar = "ttt"\n'
245 ' ret = !echo {lvar}\n'
246 ' return ret[0]\n')
247 res = ip.user_ns['test']()
248 nt.assert_in('ttt', res)
249
242 def test_bad_var_expand(self):
250 def test_bad_var_expand(self):
243 """var_expand on invalid formats shouldn't raise"""
251 """var_expand on invalid formats shouldn't raise"""
244 # SyntaxError
252 # SyntaxError
245 self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
253 self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
246 # NameError
254 # NameError
247 self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
255 self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
248 # ZeroDivisionError
256 # ZeroDivisionError
249 self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
257 self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
250
258
251 def test_silent_nopostexec(self):
259 def test_silent_nopostexec(self):
252 """run_cell(silent=True) doesn't invoke post-exec funcs"""
260 """run_cell(silent=True) doesn't invoke post-exec funcs"""
253 d = dict(called=False)
261 d = dict(called=False)
254 def set_called():
262 def set_called():
255 d['called'] = True
263 d['called'] = True
256
264
257 ip.register_post_execute(set_called)
265 ip.register_post_execute(set_called)
258 ip.run_cell("1", silent=True)
266 ip.run_cell("1", silent=True)
259 self.assertFalse(d['called'])
267 self.assertFalse(d['called'])
260 # double-check that non-silent exec did what we expected
268 # double-check that non-silent exec did what we expected
261 # silent to avoid
269 # silent to avoid
262 ip.run_cell("1")
270 ip.run_cell("1")
263 self.assertTrue(d['called'])
271 self.assertTrue(d['called'])
264 # remove post-exec
272 # remove post-exec
265 ip._post_execute.pop(set_called)
273 ip._post_execute.pop(set_called)
266
274
267 def test_silent_noadvance(self):
275 def test_silent_noadvance(self):
268 """run_cell(silent=True) doesn't advance execution_count"""
276 """run_cell(silent=True) doesn't advance execution_count"""
269 ec = ip.execution_count
277 ec = ip.execution_count
270 # silent should force store_history=False
278 # silent should force store_history=False
271 ip.run_cell("1", store_history=True, silent=True)
279 ip.run_cell("1", store_history=True, silent=True)
272
280
273 self.assertEquals(ec, ip.execution_count)
281 self.assertEquals(ec, ip.execution_count)
274 # double-check that non-silent exec did what we expected
282 # double-check that non-silent exec did what we expected
275 # silent to avoid
283 # silent to avoid
276 ip.run_cell("1", store_history=True)
284 ip.run_cell("1", store_history=True)
277 self.assertEquals(ec+1, ip.execution_count)
285 self.assertEquals(ec+1, ip.execution_count)
278
286
279 def test_silent_nodisplayhook(self):
287 def test_silent_nodisplayhook(self):
280 """run_cell(silent=True) doesn't trigger displayhook"""
288 """run_cell(silent=True) doesn't trigger displayhook"""
281 d = dict(called=False)
289 d = dict(called=False)
282
290
283 trap = ip.display_trap
291 trap = ip.display_trap
284 save_hook = trap.hook
292 save_hook = trap.hook
285
293
286 def failing_hook(*args, **kwargs):
294 def failing_hook(*args, **kwargs):
287 d['called'] = True
295 d['called'] = True
288
296
289 try:
297 try:
290 trap.hook = failing_hook
298 trap.hook = failing_hook
291 ip.run_cell("1", silent=True)
299 ip.run_cell("1", silent=True)
292 self.assertFalse(d['called'])
300 self.assertFalse(d['called'])
293 # double-check that non-silent exec did what we expected
301 # double-check that non-silent exec did what we expected
294 # silent to avoid
302 # silent to avoid
295 ip.run_cell("1")
303 ip.run_cell("1")
296 self.assertTrue(d['called'])
304 self.assertTrue(d['called'])
297 finally:
305 finally:
298 trap.hook = save_hook
306 trap.hook = save_hook
299
307
300 @skipif(sys.version_info[0] >= 3, "softspace removed in py3")
308 @skipif(sys.version_info[0] >= 3, "softspace removed in py3")
301 def test_print_softspace(self):
309 def test_print_softspace(self):
302 """Verify that softspace is handled correctly when executing multiple
310 """Verify that softspace is handled correctly when executing multiple
303 statements.
311 statements.
304
312
305 In [1]: print 1; print 2
313 In [1]: print 1; print 2
306 1
314 1
307 2
315 2
308
316
309 In [2]: print 1,; print 2
317 In [2]: print 1,; print 2
310 1 2
318 1 2
311 """
319 """
312
320
313 def test_ofind_line_magic(self):
321 def test_ofind_line_magic(self):
314 from IPython.core.magic import register_line_magic
322 from IPython.core.magic import register_line_magic
315
323
316 @register_line_magic
324 @register_line_magic
317 def lmagic(line):
325 def lmagic(line):
318 "A line magic"
326 "A line magic"
319
327
320 # Get info on line magic
328 # Get info on line magic
321 lfind = ip._ofind('lmagic')
329 lfind = ip._ofind('lmagic')
322 info = dict(found=True, isalias=False, ismagic=True,
330 info = dict(found=True, isalias=False, ismagic=True,
323 namespace = 'IPython internal', obj= lmagic.__wrapped__,
331 namespace = 'IPython internal', obj= lmagic.__wrapped__,
324 parent = None)
332 parent = None)
325 nt.assert_equal(lfind, info)
333 nt.assert_equal(lfind, info)
326
334
327 def test_ofind_cell_magic(self):
335 def test_ofind_cell_magic(self):
328 from IPython.core.magic import register_cell_magic
336 from IPython.core.magic import register_cell_magic
329
337
330 @register_cell_magic
338 @register_cell_magic
331 def cmagic(line, cell):
339 def cmagic(line, cell):
332 "A cell magic"
340 "A cell magic"
333
341
334 # Get info on cell magic
342 # Get info on cell magic
335 find = ip._ofind('cmagic')
343 find = ip._ofind('cmagic')
336 info = dict(found=True, isalias=False, ismagic=True,
344 info = dict(found=True, isalias=False, ismagic=True,
337 namespace = 'IPython internal', obj= cmagic.__wrapped__,
345 namespace = 'IPython internal', obj= cmagic.__wrapped__,
338 parent = None)
346 parent = None)
339 nt.assert_equal(find, info)
347 nt.assert_equal(find, info)
340
348
341 def test_custom_exception(self):
349 def test_custom_exception(self):
342 called = []
350 called = []
343 def my_handler(shell, etype, value, tb, tb_offset=None):
351 def my_handler(shell, etype, value, tb, tb_offset=None):
344 called.append(etype)
352 called.append(etype)
345 shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
353 shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
346
354
347 ip.set_custom_exc((ValueError,), my_handler)
355 ip.set_custom_exc((ValueError,), my_handler)
348 try:
356 try:
349 ip.run_cell("raise ValueError('test')")
357 ip.run_cell("raise ValueError('test')")
350 # Check that this was called, and only once.
358 # Check that this was called, and only once.
351 self.assertEqual(called, [ValueError])
359 self.assertEqual(called, [ValueError])
352 finally:
360 finally:
353 # Reset the custom exception hook
361 # Reset the custom exception hook
354 ip.set_custom_exc((), None)
362 ip.set_custom_exc((), None)
355
363
356
364
357 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
365 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
358
366
359 def setUp(self):
367 def setUp(self):
360 self.BASETESTDIR = tempfile.mkdtemp()
368 self.BASETESTDIR = tempfile.mkdtemp()
361 self.TESTDIR = join(self.BASETESTDIR, u"åäö")
369 self.TESTDIR = join(self.BASETESTDIR, u"åäö")
362 os.mkdir(self.TESTDIR)
370 os.mkdir(self.TESTDIR)
363 with open(join(self.TESTDIR, u"åäötestscript.py"), "w") as sfile:
371 with open(join(self.TESTDIR, u"åäötestscript.py"), "w") as sfile:
364 sfile.write("pass\n")
372 sfile.write("pass\n")
365 self.oldpath = os.getcwdu()
373 self.oldpath = os.getcwdu()
366 os.chdir(self.TESTDIR)
374 os.chdir(self.TESTDIR)
367 self.fname = u"åäötestscript.py"
375 self.fname = u"åäötestscript.py"
368
376
369 def tearDown(self):
377 def tearDown(self):
370 os.chdir(self.oldpath)
378 os.chdir(self.oldpath)
371 shutil.rmtree(self.BASETESTDIR)
379 shutil.rmtree(self.BASETESTDIR)
372
380
373 def test_1(self):
381 def test_1(self):
374 """Test safe_execfile with non-ascii path
382 """Test safe_execfile with non-ascii path
375 """
383 """
376 ip.safe_execfile(self.fname, {}, raise_exceptions=True)
384 ip.safe_execfile(self.fname, {}, raise_exceptions=True)
377
385
378
386
379 class TestSystemRaw(unittest.TestCase):
387 class TestSystemRaw(unittest.TestCase):
380 def test_1(self):
388 def test_1(self):
381 """Test system_raw with non-ascii cmd
389 """Test system_raw with non-ascii cmd
382 """
390 """
383 cmd = ur'''python -c "'åäö'" '''
391 cmd = ur'''python -c "'åäö'" '''
384 ip.system_raw(cmd)
392 ip.system_raw(cmd)
385
393
386
394
387 def test__IPYTHON__():
395 def test__IPYTHON__():
388 # This shouldn't raise a NameError, that's all
396 # This shouldn't raise a NameError, that's all
389 __IPYTHON__
397 __IPYTHON__
General Comments 0
You need to be logged in to leave comments. Login now