Coverage for idle_test/test_run.py: 97%

1"Test run, coverage 54%." 

2 

3from idlelib import run (empty)

4import io (empty)

5import sys (empty)

6from test.support import captured_output, captured_stderr (empty)

7import unittest (empty)

8from unittest import mock (empty)

9import idlelib (empty)

10from idlelib.idle_test.mock_idle import Func (empty)

11 

12idlelib.testing = True # Use {} for executing test user code. (empty)

13 

14 

15class ExceptionTest(unittest.TestCase): (empty)

16 

17 def test_print_exception_unhashable(self): (empty)

18 class UnhashableException(Exception): 1 ctx1i

19 def __eq__(self, other): 1 ctx1i

20 return True 

21 

22 ex1 = UnhashableException('ex1') 1 ctx1i

23 ex2 = UnhashableException('ex2') 1 ctx1i

24 try: 1 ctx1i

25 raise ex2 from ex1 1 ctx1i

26 except UnhashableException: 1 ctx1i

27 try: 1 ctx1i

28 raise ex1 1 ctx1i

29 except UnhashableException: 1 ctx1i

30 with captured_stderr() as output: 1 ctx1i

31 with mock.patch.object(run, 'cleanup_traceback') as ct: 1 ctx1i

32 ct.side_effect = lambda t, e: t 1 ctx1i

33 run.print_exception() 1 ctx1i

34 

35 tb = output.getvalue().strip().splitlines() 1 ctx1i

36 self.assertEqual(11, len(tb)) 1 ctx1i

37 self.assertIn('UnhashableException: ex2', tb[3]) 1 ctx1i

38 self.assertIn('UnhashableException: ex1', tb[10]) 1 ctx1i

39 

40 data = (('1/0', ZeroDivisionError, "division by zero\n"), (empty)

41 ('abc', NameError, "name 'abc' is not defined. " 

42 "Did you mean: 'abs'? " 

43 "Or did you forget to import 'abc'?\n"), 

44 ('int.reel', AttributeError, 

45 "type object 'int' has no attribute 'reel'. " 

46 "Did you mean: 'real'?\n"), 

47 ) 

48 

49 def test_get_message(self): (empty)

50 for code, exc, msg in self.data: 1 ctx1p

51 with self.subTest(code=code): 1 ctx1p

52 try: 1 ctx1p

53 eval(compile(code, '', 'eval')) 1 ctx1p

54 except exc: 1 ctx1p

55 typ, val, tb = sys.exc_info() 1 ctx1p

56 actual = run.get_message_lines(typ, val, tb)[0] 1 ctx1p

57 expect = f'{exc.__name__}: {msg}' 1 ctx1p

58 self.assertEqual(actual, expect) 1 ctx1p

59 

60 @mock.patch.object(run, 'cleanup_traceback', (empty)

61 new_callable=lambda: (lambda t, e: None)) 

62 def test_get_multiple_message(self, mock): (empty)

63 d = self.data 1 ctx1j

64 data2 = ((d[0], d[1]), (d[1], d[2]), (d[2], d[0])) 1 ctx1j

65 subtests = 0 1 ctx1j

66 for (code1, exc1, msg1), (code2, exc2, msg2) in data2: 1 ctx1j

67 with self.subTest(codes=(code1,code2)): 1 ctx1j

68 try: 1 ctx1j

69 eval(compile(code1, '', 'eval')) 1 ctx1j

70 except exc1: 1 ctx1j

71 try: 1 ctx1j

72 eval(compile(code2, '', 'eval')) 1 ctx1j

73 except exc2: 1 ctx1j

74 with captured_stderr() as output: 1 ctx1j

75 run.print_exception() 1 ctx1j

76 actual = output.getvalue() 1 ctx1j

77 self.assertIn(msg1, actual) 1 ctx1j

78 self.assertIn(msg2, actual) 1 ctx1j

79 subtests += 1 1 ctx1j

80 self.assertEqual(subtests, len(data2)) # All subtests ran? 1 ctx1j

81 

82# StdioFile tests. 

83 

84class S(str): (empty)

85 def __str__(self): (empty)

86 return '%s:str' % type(self).__name__ 

87 def __unicode__(self): (empty)

88 return '%s:unicode' % type(self).__name__ 

89 def __len__(self): (empty)

90 return 3 

91 def __iter__(self): (empty)

92 return iter('abc') 

93 def __getitem__(self, *args): (empty)

94 return '%s:item' % type(self).__name__ 

95 def __getslice__(self, *args): (empty)

96 return '%s:slice' % type(self).__name__ 

97 

98 

99class MockShell: (empty)

100 def __init__(self): (empty)

101 self.reset() 12 ctx1klfcdqnmrehb

102 def write(self, *args): (empty)

103 self.written.append(args) 4 ctx1nehb

104 def readline(self): (empty)

105 return self.lines.pop() 4 ctx1kfcd

106 def close(self): (empty)

107 pass 2 ctx1ak

108 def reset(self): (empty)

109 self.written = [] 12 ctx1klfcdqnmrehb

110 def push(self, lines): (empty)

111 self.lines = list(lines)[::-1] 4 ctx1kfcd

112 

113 

114class StdInputFilesTest(unittest.TestCase): (empty)

115 

116 def test_misc(self): (empty)

117 shell = MockShell() 1 ctx1l

118 f = run.StdInputFile(shell, 'stdin') 1 ctx1l

119 self.assertIsInstance(f, io.TextIOBase) 1 ctx1l

120 self.assertEqual(f.encoding, 'utf-8') 1 ctx1l

121 self.assertEqual(f.errors, 'strict') 1 ctx1l

122 self.assertIsNone(f.newlines) 1 ctx1l

123 self.assertEqual(f.name, '<stdin>') 1 ctx1l

124 self.assertFalse(f.closed) 1 ctx1l

125 self.assertTrue(f.isatty()) 1 ctx1l

126 self.assertTrue(f.readable()) 1 ctx1l

127 self.assertFalse(f.writable()) 1 ctx1l

128 self.assertFalse(f.seekable()) 1 ctx1l

129 

130 def test_unsupported(self): (empty)

131 shell = MockShell() 1 ctx1q

132 f = run.StdInputFile(shell, 'stdin') 1 ctx1q

133 self.assertRaises(OSError, f.fileno) 1 ctx1q

134 self.assertRaises(OSError, f.tell) 1 ctx1q

135 self.assertRaises(OSError, f.seek, 0) 1 ctx1q

136 self.assertRaises(OSError, f.write, 'x') 1 ctx1q

137 self.assertRaises(OSError, f.writelines, ['x']) 1 ctx1q

138 

139 def test_read(self): (empty)

140 shell = MockShell() 1 ctx1f

141 f = run.StdInputFile(shell, 'stdin') 1 ctx1f

142 shell.push(['one\n', 'two\n', '']) 1 ctx1f

143 self.assertEqual(f.read(), 'one\ntwo\n') 1 ctx1f

144 shell.push(['one\n', 'two\n', '']) 1 ctx1f

145 self.assertEqual(f.read(-1), 'one\ntwo\n') 1 ctx1f

146 shell.push(['one\n', 'two\n', '']) 1 ctx1f

147 self.assertEqual(f.read(None), 'one\ntwo\n') 1 ctx1f

148 shell.push(['one\n', 'two\n', 'three\n', '']) 1 ctx1f

149 self.assertEqual(f.read(2), 'on') 1 ctx1f

150 self.assertEqual(f.read(3), 'e\nt') 1 ctx1f

151 self.assertEqual(f.read(10), 'wo\nthree\n') 1 ctx1f

152 

153 shell.push(['one\n', 'two\n']) 1 ctx1f

154 self.assertEqual(f.read(0), '') 1 ctx1f

155 self.assertRaises(TypeError, f.read, 1.5) 1 ctx1f

156 self.assertRaises(TypeError, f.read, '1') 1 ctx1f

157 self.assertRaises(TypeError, f.read, 1, 1) 1 ctx1f

158 

159 def test_readline(self): (empty)

160 shell = MockShell() 1 ctx1c

161 f = run.StdInputFile(shell, 'stdin') 1 ctx1c

162 shell.push(['one\n', 'two\n', 'three\n', 'four\n']) 1 ctx1c

163 self.assertEqual(f.readline(), 'one\n') 1 ctx1c

164 self.assertEqual(f.readline(-1), 'two\n') 1 ctx1c

165 self.assertEqual(f.readline(None), 'three\n') 1 ctx1c

166 shell.push(['one\ntwo\n']) 1 ctx1c

167 self.assertEqual(f.readline(), 'one\n') 1 ctx1c

168 self.assertEqual(f.readline(), 'two\n') 1 ctx1c

169 shell.push(['one', 'two', 'three']) 1 ctx1c

170 self.assertEqual(f.readline(), 'one') 1 ctx1c

171 self.assertEqual(f.readline(), 'two') 1 ctx1c

172 shell.push(['one\n', 'two\n', 'three\n']) 1 ctx1c

173 self.assertEqual(f.readline(2), 'on') 1 ctx1c

174 self.assertEqual(f.readline(1), 'e') 1 ctx1c

175 self.assertEqual(f.readline(1), '\n') 1 ctx1c

176 self.assertEqual(f.readline(10), 'two\n') 1 ctx1c

177 

178 shell.push(['one\n', 'two\n']) 1 ctx1c

179 self.assertEqual(f.readline(0), '') 1 ctx1c

180 self.assertRaises(TypeError, f.readlines, 1.5) 1 ctx1c

181 self.assertRaises(TypeError, f.readlines, '1') 1 ctx1c

182 self.assertRaises(TypeError, f.readlines, 1, 1) 1 ctx1c

183 

184 def test_readlines(self): (empty)

185 shell = MockShell() 1 ctx1d

186 f = run.StdInputFile(shell, 'stdin') 1 ctx1d

187 shell.push(['one\n', 'two\n', '']) 1 ctx1d

188 self.assertEqual(f.readlines(), ['one\n', 'two\n']) 1 ctx1d

189 shell.push(['one\n', 'two\n', '']) 1 ctx1d

190 self.assertEqual(f.readlines(-1), ['one\n', 'two\n']) 1 ctx1d

191 shell.push(['one\n', 'two\n', '']) 1 ctx1d

192 self.assertEqual(f.readlines(None), ['one\n', 'two\n']) 1 ctx1d

193 shell.push(['one\n', 'two\n', '']) 1 ctx1d

194 self.assertEqual(f.readlines(0), ['one\n', 'two\n']) 1 ctx1d

195 shell.push(['one\n', 'two\n', '']) 1 ctx1d

196 self.assertEqual(f.readlines(3), ['one\n']) 1 ctx1d

197 shell.push(['one\n', 'two\n', '']) 1 ctx1d

198 self.assertEqual(f.readlines(4), ['one\n', 'two\n']) 1 ctx1d

199 

200 shell.push(['one\n', 'two\n', '']) 1 ctx1d

201 self.assertRaises(TypeError, f.readlines, 1.5) 1 ctx1d

202 self.assertRaises(TypeError, f.readlines, '1') 1 ctx1d

203 self.assertRaises(TypeError, f.readlines, 1, 1) 1 ctx1d

204 

205 def test_close(self): (empty)

206 shell = MockShell() 1 ctx1k

207 f = run.StdInputFile(shell, 'stdin') 1 ctx1k

208 shell.push(['one\n', 'two\n', '']) 1 ctx1k

209 self.assertFalse(f.closed) 1 ctx1k

210 self.assertEqual(f.readline(), 'one\n') 1 ctx1k

211 f.close() 1 ctx1k

212 self.assertFalse(f.closed) 1 ctx1k

213 self.assertEqual(f.readline(), 'two\n') 1 ctx1k

214 self.assertRaises(TypeError, f.close, 1) 1 ctx1k

215 

216 

217class StdOutputFilesTest(unittest.TestCase): (empty)

218 

219 def test_misc(self): (empty)

220 shell = MockShell() 1 ctx1m

221 f = run.StdOutputFile(shell, 'stdout') 1 ctx1m

222 self.assertIsInstance(f, io.TextIOBase) 1 ctx1m

223 self.assertEqual(f.encoding, 'utf-8') 1 ctx1m

224 self.assertEqual(f.errors, 'strict') 1 ctx1m

225 self.assertIsNone(f.newlines) 1 ctx1m

226 self.assertEqual(f.name, '<stdout>') 1 ctx1m

227 self.assertFalse(f.closed) 1 ctx1m

228 self.assertTrue(f.isatty()) 1 ctx1m

229 self.assertFalse(f.readable()) 1 ctx1m

230 self.assertTrue(f.writable()) 1 ctx1m

231 self.assertFalse(f.seekable()) 1 ctx1m

232 

233 def test_unsupported(self): (empty)

234 shell = MockShell() 1 ctx1r

235 f = run.StdOutputFile(shell, 'stdout') 1 ctx1r

236 self.assertRaises(OSError, f.fileno) 1 ctx1r

237 self.assertRaises(OSError, f.tell) 1 ctx1r

238 self.assertRaises(OSError, f.seek, 0) 1 ctx1r

239 self.assertRaises(OSError, f.read, 0) 1 ctx1r

240 self.assertRaises(OSError, f.readline, 0) 1 ctx1r

241 

242 def test_write(self): (empty)

243 shell = MockShell() 1 ctx1e

244 f = run.StdOutputFile(shell, 'stdout') 1 ctx1e

245 f.write('test') 1 ctx1e

246 self.assertEqual(shell.written, [('test', 'stdout')]) 1 ctx1e

247 shell.reset() 1 ctx1e

248 f.write('t\xe8\u015b\U0001d599') 1 ctx1e

249 self.assertEqual(shell.written, [('t\xe8\u015b\U0001d599', 'stdout')]) 1 ctx1e

250 shell.reset() 1 ctx1e

251 

252 f.write(S('t\xe8\u015b\U0001d599')) 1 ctx1e

253 self.assertEqual(shell.written, [('t\xe8\u015b\U0001d599', 'stdout')]) 1 ctx1e

254 self.assertEqual(type(shell.written[0][0]), str) 1 ctx1e

255 shell.reset() 1 ctx1e

256 

257 self.assertRaises(TypeError, f.write) 1 ctx1e

258 self.assertEqual(shell.written, []) 1 ctx1e

259 self.assertRaises(TypeError, f.write, b'test') 1 ctx1e

260 self.assertRaises(TypeError, f.write, 123) 1 ctx1e

261 self.assertEqual(shell.written, []) 1 ctx1e

262 self.assertRaises(TypeError, f.write, 'test', 'spam') 1 ctx1e

263 self.assertEqual(shell.written, []) 1 ctx1e

264 

265 def test_write_stderr_nonencodable(self): (empty)

266 shell = MockShell() 1 ctx1h

267 f = run.StdOutputFile(shell, 'stderr', 'iso-8859-15', 'backslashreplace') 1 ctx1h

268 f.write('t\xe8\u015b\U0001d599\xa4') 1 ctx1h

269 self.assertEqual(shell.written, [('t\xe8\\u015b\\U0001d599\\xa4', 'stderr')]) 1 ctx1h

270 shell.reset() 1 ctx1h

271 

272 f.write(S('t\xe8\u015b\U0001d599\xa4')) 1 ctx1h

273 self.assertEqual(shell.written, [('t\xe8\\u015b\\U0001d599\\xa4', 'stderr')]) 1 ctx1h

274 self.assertEqual(type(shell.written[0][0]), str) 1 ctx1h

275 shell.reset() 1 ctx1h

276 

277 self.assertRaises(TypeError, f.write) 1 ctx1h

278 self.assertEqual(shell.written, []) 1 ctx1h

279 self.assertRaises(TypeError, f.write, b'test') 1 ctx1h

280 self.assertRaises(TypeError, f.write, 123) 1 ctx1h

281 self.assertEqual(shell.written, []) 1 ctx1h

282 self.assertRaises(TypeError, f.write, 'test', 'spam') 1 ctx1h

283 self.assertEqual(shell.written, []) 1 ctx1h

284 

285 def test_writelines(self): (empty)

286 shell = MockShell() 1 ctx1b

287 f = run.StdOutputFile(shell, 'stdout') 1 ctx1b

288 f.writelines([]) 1 ctx1b

289 self.assertEqual(shell.written, []) 1 ctx1b

290 shell.reset() 1 ctx1b

291 f.writelines(['one\n', 'two']) 1 ctx1b

292 self.assertEqual(shell.written, 1 ctx1b

293 [('one\n', 'stdout'), ('two', 'stdout')]) 

294 shell.reset() 1 ctx1b

295 f.writelines(['on\xe8\n', 'tw\xf2']) 1 ctx1b

296 self.assertEqual(shell.written, 1 ctx1b

297 [('on\xe8\n', 'stdout'), ('tw\xf2', 'stdout')]) 

298 shell.reset() 1 ctx1b

299 

300 f.writelines([S('t\xe8st')]) 1 ctx1b

301 self.assertEqual(shell.written, [('t\xe8st', 'stdout')]) 1 ctx1b

302 self.assertEqual(type(shell.written[0][0]), str) 1 ctx1b

303 shell.reset() 1 ctx1b

304 

305 self.assertRaises(TypeError, f.writelines) 1 ctx1b

306 self.assertEqual(shell.written, []) 1 ctx1b

307 self.assertRaises(TypeError, f.writelines, 123) 1 ctx1b

308 self.assertEqual(shell.written, []) 1 ctx1b

309 self.assertRaises(TypeError, f.writelines, [b'test']) 1 ctx1b

310 self.assertRaises(TypeError, f.writelines, [123]) 1 ctx1b

311 self.assertEqual(shell.written, []) 1 ctx1b

312 self.assertRaises(TypeError, f.writelines, [], []) 1 ctx1b

313 self.assertEqual(shell.written, []) 1 ctx1b

314 

315 def test_close(self): (empty)

316 shell = MockShell() 1 ctx1n

317 f = run.StdOutputFile(shell, 'stdout') 1 ctx1n

318 self.assertFalse(f.closed) 1 ctx1n

319 f.write('test') 1 ctx1n

320 f.close() 1 ctx1n

321 self.assertTrue(f.closed) 1 ctx1n

322 self.assertRaises(ValueError, f.write, 'x') 1 ctx1n

323 self.assertEqual(shell.written, [('test', 'stdout')]) 1 ctx1n

324 f.close() 1 ctx1n

325 self.assertRaises(TypeError, f.close, 1) 1 ctx1n

326 

327 

328class RecursionLimitTest(unittest.TestCase): (empty)

329 # Test (un)install_recursionlimit_wrappers and fixdoc. 

330 

331 def test_bad_setrecursionlimit_calls(self): (empty)

332 run.install_recursionlimit_wrappers() 1 ctx1t

333 self.addCleanup(run.uninstall_recursionlimit_wrappers) 1 ctx1t

334 f = sys.setrecursionlimit 1 ctx1t

335 self.assertRaises(TypeError, f, limit=100) 1 ctx1t

336 self.assertRaises(TypeError, f, 100, 1000) 1 ctx1t

337 self.assertRaises(ValueError, f, 0) 1 ctx1t

338 

339 def test_roundtrip(self): (empty)

340 run.install_recursionlimit_wrappers() 1 ctx1s

341 self.addCleanup(run.uninstall_recursionlimit_wrappers) 1 ctx1s

342 

343 # Check that setting the recursion limit works. 

344 orig_reclimit = sys.getrecursionlimit() 1 ctx1s

345 self.addCleanup(sys.setrecursionlimit, orig_reclimit) 1 ctx1s

346 sys.setrecursionlimit(orig_reclimit + 3) 1 ctx1s

347 

348 # Check that the new limit is returned by sys.getrecursionlimit(). 

349 new_reclimit = sys.getrecursionlimit() 1 ctx1s

350 self.assertEqual(new_reclimit, orig_reclimit + 3) 1 ctx1s

351 

352 def test_default_recursion_limit_preserved(self): (empty)

353 orig_reclimit = sys.getrecursionlimit() 1 ctx1v

354 run.install_recursionlimit_wrappers() 1 ctx1v

355 self.addCleanup(run.uninstall_recursionlimit_wrappers) 1 ctx1v

356 new_reclimit = sys.getrecursionlimit() 1 ctx1v

357 self.assertEqual(new_reclimit, orig_reclimit) 1 ctx1v

358 

359 def test_fixdoc(self): (empty)

360 # Put here until better place for miscellaneous test. 

361 def func(): "docstring" 361 ↛ exitline 361 didn't return from function 'func'1 ctx1u

362 run.fixdoc(func, "more") 1 ctx1u

363 self.assertEqual(func.__doc__, "docstring\n\nmore") 1 ctx1u

364 func.__doc__ = None 1 ctx1u

365 run.fixdoc(func, "more") 1 ctx1u

366 self.assertEqual(func.__doc__, "more") 1 ctx1u

367 

368 

369class HandleErrorTest(unittest.TestCase): (empty)

370 # Method of MyRPCServer 

371 def test_fatal_error(self): (empty)

372 eq = self.assertEqual 1 ctx1g

373 with captured_output('__stderr__') as err,\ 1 ctx1g

374 mock.patch('idlelib.run.thread.interrupt_main', 

375 new_callable=Func) as func: 

376 try: 1 ctx1g

377 raise EOFError 1 ctx1g

378 except EOFError: 1 ctx1g

379 run.MyRPCServer.handle_error(None, 'abc', '123') 1 ctx1g

380 eq(run.exit_now, True) 1 ctx1g

381 run.exit_now = False 1 ctx1g

382 eq(err.getvalue(), '') 1 ctx1g

383 

384 try: 1 ctx1g

385 raise IndexError 1 ctx1g

386 except IndexError: 1 ctx1g

387 run.MyRPCServer.handle_error(None, 'abc', '123') 1 ctx1g

388 eq(run.quitting, True) 1 ctx1g

389 run.quitting = False 1 ctx1g

390 msg = err.getvalue() 1 ctx1g

391 self.assertIn('abc', msg) 1 ctx1g

392 self.assertIn('123', msg) 1 ctx1g

393 self.assertIn('IndexError', msg) 1 ctx1g

394 eq(func.called, 2) 1 ctx1g

395 

396 

397class ExecRuncodeTest(unittest.TestCase): (empty)

398 

399 @classmethod (empty)

400 def setUpClass(cls): (empty)

401 cls.addClassCleanup(setattr,run,'print_exception',run.print_exception) (empty)

402 cls.prt = Func() # Need reference. (empty)

403 run.print_exception = cls.prt (empty)

404 mockrpc = mock.Mock() (empty)

405 mockrpc.console.getvar = Func(result=False) (empty)

406 cls.ex = run.Executive(mockrpc) (empty)

407 

408 @classmethod (empty)

409 def tearDownClass(cls): (empty)

410 assert sys.excepthook == sys.__excepthook__ (empty)

411 

412 def test_exceptions(self): (empty)

413 ex = self.ex 1 ctx1o

414 ex.runcode('1/0') 1 ctx1o

415 self.assertIs(ex.user_exc_info[0], ZeroDivisionError) 1 ctx1o

416 

417 self.addCleanup(setattr, sys, 'excepthook', sys.__excepthook__) 1 ctx1o

418 sys.excepthook = lambda t, e, tb: run.print_exception(t) 1 ctx1o

419 ex.runcode('1/0') 1 ctx1o

420 self.assertIs(self.prt.args[0], ZeroDivisionError) 1 ctx1o

421 

422 sys.excepthook = lambda: None 422 ↛ exitline 422 didn't run the lambda on line 4221 ctx1o

423 ex.runcode('1/0') 1 ctx1o

424 t, e, tb = ex.user_exc_info 1 ctx1o

425 self.assertIs(t, TypeError) 1 ctx1o

426 self.assertTrue(isinstance(e.__context__, ZeroDivisionError)) 1 ctx1o

427 

428 

429if __name__ == '__main__': 429 ↛ 430line 429 didn't jump to line 430, because the condition on line 429 was never true(empty)

430 unittest.main(verbosity=2)