1 # tests command line execution of scripts
2
3 import contextlib
4 import importlib
5 import importlib.machinery
6 import zipimport
7 import unittest
8 import sys
9 import os
10 import os.path
11 import py_compile
12 import subprocess
13 import io
14
15 import textwrap
16 from test import support
17 from test.support import import_helper
18 from test.support import os_helper
19 from test.support.script_helper import (
20 make_pkg, make_script, make_zip_pkg, make_zip_script,
21 assert_python_ok, assert_python_failure, spawn_python, kill_python)
22
23 verbose = support.verbose
24
25 example_args = ['test1', 'test2', 'test3']
26
27 test_source = """\
28 # Script may be run with optimisation enabled, so don't rely on assert
29 # statements being executed
30 def assertEqual(lhs, rhs):
31 if lhs != rhs:
32 raise AssertionError('%r != %r' % (lhs, rhs))
33 def assertIdentical(lhs, rhs):
34 if lhs is not rhs:
35 raise AssertionError('%r is not %r' % (lhs, rhs))
36 # Check basic code execution
37 result = ['Top level assignment']
38 def f():
39 result.append('Lower level reference')
40 f()
41 assertEqual(result, ['Top level assignment', 'Lower level reference'])
42 # Check population of magic variables
43 assertEqual(__name__, '__main__')
44 from importlib.machinery import BuiltinImporter
45 _loader = __loader__ if __loader__ is BuiltinImporter else type(__loader__)
46 print('__loader__==%a' % _loader)
47 print('__file__==%a' % __file__)
48 print('__cached__==%a' % __cached__)
49 print('__package__==%r' % __package__)
50 # Check PEP 451 details
51 import os.path
52 if __package__ is not None:
53 print('__main__ was located through the import system')
54 assertIdentical(__spec__.loader, __loader__)
55 expected_spec_name = os.path.splitext(os.path.basename(__file__))[0]
56 if __package__:
57 expected_spec_name = __package__ + "." + expected_spec_name
58 assertEqual(__spec__.name, expected_spec_name)
59 assertEqual(__spec__.parent, __package__)
60 assertIdentical(__spec__.submodule_search_locations, None)
61 assertEqual(__spec__.origin, __file__)
62 if __spec__.cached is not None:
63 assertEqual(__spec__.cached, __cached__)
64 # Check the sys module
65 import sys
66 assertIdentical(globals(), sys.modules[__name__].__dict__)
67 if __spec__ is not None:
68 # XXX: We're not currently making __main__ available under its real name
69 pass # assertIdentical(globals(), sys.modules[__spec__.name].__dict__)
70 from test import test_cmd_line_script
71 example_args_list = test_cmd_line_script.example_args
72 assertEqual(sys.argv[1:], example_args_list)
73 print('sys.argv[0]==%a' % sys.argv[0])
74 print('sys.path[0]==%a' % sys.path[0])
75 # Check the working directory
76 import os
77 print('cwd==%a' % os.getcwd())
78 """
79
80 def _make_test_script(script_dir, script_basename, source=test_source):
81 to_return = make_script(script_dir, script_basename, source)
82 importlib.invalidate_caches()
83 return to_return
84
85 def _make_test_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename,
86 source=test_source, depth=1):
87 to_return = make_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename,
88 source, depth)
89 importlib.invalidate_caches()
90 return to_return
91
92 class ESC[4;38;5;81mCmdLineTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
93 def _check_output(self, script_name, exit_code, data,
94 expected_file, expected_argv0,
95 expected_path0, expected_package,
96 expected_loader, expected_cwd=None):
97 if verbose > 1:
98 print("Output from test script %r:" % script_name)
99 print(repr(data))
100 self.assertEqual(exit_code, 0)
101 printed_loader = '__loader__==%a' % expected_loader
102 printed_file = '__file__==%a' % expected_file
103 printed_package = '__package__==%r' % expected_package
104 printed_argv0 = 'sys.argv[0]==%a' % expected_argv0
105 printed_path0 = 'sys.path[0]==%a' % expected_path0
106 if expected_cwd is None:
107 expected_cwd = os.getcwd()
108 printed_cwd = 'cwd==%a' % expected_cwd
109 if verbose > 1:
110 print('Expected output:')
111 print(printed_file)
112 print(printed_package)
113 print(printed_argv0)
114 print(printed_cwd)
115 self.assertIn(printed_loader.encode('utf-8'), data)
116 self.assertIn(printed_file.encode('utf-8'), data)
117 self.assertIn(printed_package.encode('utf-8'), data)
118 self.assertIn(printed_argv0.encode('utf-8'), data)
119 # PYTHONSAFEPATH=1 changes the default sys.path[0]
120 if not sys.flags.safe_path:
121 self.assertIn(printed_path0.encode('utf-8'), data)
122 self.assertIn(printed_cwd.encode('utf-8'), data)
123
124 def _check_script(self, script_exec_args, expected_file,
125 expected_argv0, expected_path0,
126 expected_package, expected_loader,
127 *cmd_line_switches, cwd=None, **env_vars):
128 if isinstance(script_exec_args, str):
129 script_exec_args = [script_exec_args]
130 run_args = [*support.optim_args_from_interpreter_flags(),
131 *cmd_line_switches, *script_exec_args, *example_args]
132 rc, out, err = assert_python_ok(
133 *run_args, __isolated=False, __cwd=cwd, **env_vars
134 )
135 self._check_output(script_exec_args, rc, out + err, expected_file,
136 expected_argv0, expected_path0,
137 expected_package, expected_loader, cwd)
138
139 def _check_import_error(self, script_exec_args, expected_msg,
140 *cmd_line_switches, cwd=None, **env_vars):
141 if isinstance(script_exec_args, str):
142 script_exec_args = (script_exec_args,)
143 else:
144 script_exec_args = tuple(script_exec_args)
145 run_args = cmd_line_switches + script_exec_args
146 rc, out, err = assert_python_failure(
147 *run_args, __isolated=False, __cwd=cwd, **env_vars
148 )
149 if verbose > 1:
150 print(f'Output from test script {script_exec_args!r:}')
151 print(repr(err))
152 print('Expected output: %r' % expected_msg)
153 self.assertIn(expected_msg.encode('utf-8'), err)
154
155 def test_dash_c_loader(self):
156 rc, out, err = assert_python_ok("-c", "print(__loader__)")
157 expected = repr(importlib.machinery.BuiltinImporter).encode("utf-8")
158 self.assertIn(expected, out)
159
160 def test_stdin_loader(self):
161 # Unfortunately, there's no way to automatically test the fully
162 # interactive REPL, since that code path only gets executed when
163 # stdin is an interactive tty.
164 p = spawn_python()
165 try:
166 p.stdin.write(b"print(__loader__)\n")
167 p.stdin.flush()
168 finally:
169 out = kill_python(p)
170 expected = repr(importlib.machinery.BuiltinImporter).encode("utf-8")
171 self.assertIn(expected, out)
172
173 @contextlib.contextmanager
174 def interactive_python(self, separate_stderr=False):
175 if separate_stderr:
176 p = spawn_python('-i', stderr=subprocess.PIPE)
177 stderr = p.stderr
178 else:
179 p = spawn_python('-i', stderr=subprocess.STDOUT)
180 stderr = p.stdout
181 try:
182 # Drain stderr until prompt
183 while True:
184 data = stderr.read(4)
185 if data == b">>> ":
186 break
187 stderr.readline()
188 yield p
189 finally:
190 kill_python(p)
191 stderr.close()
192
193 def check_repl_stdout_flush(self, separate_stderr=False):
194 with self.interactive_python(separate_stderr) as p:
195 p.stdin.write(b"print('foo')\n")
196 p.stdin.flush()
197 self.assertEqual(b'foo', p.stdout.readline().strip())
198
199 def check_repl_stderr_flush(self, separate_stderr=False):
200 with self.interactive_python(separate_stderr) as p:
201 p.stdin.write(b"1/0\n")
202 p.stdin.flush()
203 stderr = p.stderr if separate_stderr else p.stdout
204 self.assertIn(b'Traceback ', stderr.readline())
205 self.assertIn(b'File "<stdin>"', stderr.readline())
206 self.assertIn(b'ZeroDivisionError', stderr.readline())
207
208 def test_repl_stdout_flush(self):
209 self.check_repl_stdout_flush()
210
211 def test_repl_stdout_flush_separate_stderr(self):
212 self.check_repl_stdout_flush(True)
213
214 def test_repl_stderr_flush(self):
215 self.check_repl_stderr_flush()
216
217 def test_repl_stderr_flush_separate_stderr(self):
218 self.check_repl_stderr_flush(True)
219
220 def test_basic_script(self):
221 with os_helper.temp_dir() as script_dir:
222 script_name = _make_test_script(script_dir, 'script')
223 self._check_script(script_name, script_name, script_name,
224 script_dir, None,
225 importlib.machinery.SourceFileLoader,
226 expected_cwd=script_dir)
227
228 def test_script_abspath(self):
229 # pass the script using the relative path, expect the absolute path
230 # in __file__
231 with os_helper.temp_cwd() as script_dir:
232 self.assertTrue(os.path.isabs(script_dir), script_dir)
233
234 script_name = _make_test_script(script_dir, 'script')
235 relative_name = os.path.basename(script_name)
236 self._check_script(relative_name, script_name, relative_name,
237 script_dir, None,
238 importlib.machinery.SourceFileLoader)
239
240 def test_script_compiled(self):
241 with os_helper.temp_dir() as script_dir:
242 script_name = _make_test_script(script_dir, 'script')
243 py_compile.compile(script_name, doraise=True)
244 os.remove(script_name)
245 pyc_file = import_helper.make_legacy_pyc(script_name)
246 self._check_script(pyc_file, pyc_file,
247 pyc_file, script_dir, None,
248 importlib.machinery.SourcelessFileLoader)
249
250 def test_directory(self):
251 with os_helper.temp_dir() as script_dir:
252 script_name = _make_test_script(script_dir, '__main__')
253 self._check_script(script_dir, script_name, script_dir,
254 script_dir, '',
255 importlib.machinery.SourceFileLoader)
256
257 def test_directory_compiled(self):
258 with os_helper.temp_dir() as script_dir:
259 script_name = _make_test_script(script_dir, '__main__')
260 py_compile.compile(script_name, doraise=True)
261 os.remove(script_name)
262 pyc_file = import_helper.make_legacy_pyc(script_name)
263 self._check_script(script_dir, pyc_file, script_dir,
264 script_dir, '',
265 importlib.machinery.SourcelessFileLoader)
266
267 def test_directory_error(self):
268 with os_helper.temp_dir() as script_dir:
269 msg = "can't find '__main__' module in %r" % script_dir
270 self._check_import_error(script_dir, msg)
271
272 def test_zipfile(self):
273 with os_helper.temp_dir() as script_dir:
274 script_name = _make_test_script(script_dir, '__main__')
275 zip_name, run_name = make_zip_script(script_dir, 'test_zip', script_name)
276 self._check_script(zip_name, run_name, zip_name, zip_name, '',
277 zipimport.zipimporter)
278
279 def test_zipfile_compiled_timestamp(self):
280 with os_helper.temp_dir() as script_dir:
281 script_name = _make_test_script(script_dir, '__main__')
282 compiled_name = py_compile.compile(
283 script_name, doraise=True,
284 invalidation_mode=py_compile.PycInvalidationMode.TIMESTAMP)
285 zip_name, run_name = make_zip_script(script_dir, 'test_zip', compiled_name)
286 self._check_script(zip_name, run_name, zip_name, zip_name, '',
287 zipimport.zipimporter)
288
289 def test_zipfile_compiled_checked_hash(self):
290 with os_helper.temp_dir() as script_dir:
291 script_name = _make_test_script(script_dir, '__main__')
292 compiled_name = py_compile.compile(
293 script_name, doraise=True,
294 invalidation_mode=py_compile.PycInvalidationMode.CHECKED_HASH)
295 zip_name, run_name = make_zip_script(script_dir, 'test_zip', compiled_name)
296 self._check_script(zip_name, run_name, zip_name, zip_name, '',
297 zipimport.zipimporter)
298
299 def test_zipfile_compiled_unchecked_hash(self):
300 with os_helper.temp_dir() as script_dir:
301 script_name = _make_test_script(script_dir, '__main__')
302 compiled_name = py_compile.compile(
303 script_name, doraise=True,
304 invalidation_mode=py_compile.PycInvalidationMode.UNCHECKED_HASH)
305 zip_name, run_name = make_zip_script(script_dir, 'test_zip', compiled_name)
306 self._check_script(zip_name, run_name, zip_name, zip_name, '',
307 zipimport.zipimporter)
308
309 def test_zipfile_error(self):
310 with os_helper.temp_dir() as script_dir:
311 script_name = _make_test_script(script_dir, 'not_main')
312 zip_name, run_name = make_zip_script(script_dir, 'test_zip', script_name)
313 msg = "can't find '__main__' module in %r" % zip_name
314 self._check_import_error(zip_name, msg)
315
316 def test_module_in_package(self):
317 with os_helper.temp_dir() as script_dir:
318 pkg_dir = os.path.join(script_dir, 'test_pkg')
319 make_pkg(pkg_dir)
320 script_name = _make_test_script(pkg_dir, 'script')
321 self._check_script(["-m", "test_pkg.script"], script_name, script_name,
322 script_dir, 'test_pkg',
323 importlib.machinery.SourceFileLoader,
324 cwd=script_dir)
325
326 def test_module_in_package_in_zipfile(self):
327 with os_helper.temp_dir() as script_dir:
328 zip_name, run_name = _make_test_zip_pkg(script_dir, 'test_zip', 'test_pkg', 'script')
329 self._check_script(["-m", "test_pkg.script"], run_name, run_name,
330 script_dir, 'test_pkg', zipimport.zipimporter,
331 PYTHONPATH=zip_name, cwd=script_dir)
332
333 def test_module_in_subpackage_in_zipfile(self):
334 with os_helper.temp_dir() as script_dir:
335 zip_name, run_name = _make_test_zip_pkg(script_dir, 'test_zip', 'test_pkg', 'script', depth=2)
336 self._check_script(["-m", "test_pkg.test_pkg.script"], run_name, run_name,
337 script_dir, 'test_pkg.test_pkg',
338 zipimport.zipimporter,
339 PYTHONPATH=zip_name, cwd=script_dir)
340
341 def test_package(self):
342 with os_helper.temp_dir() as script_dir:
343 pkg_dir = os.path.join(script_dir, 'test_pkg')
344 make_pkg(pkg_dir)
345 script_name = _make_test_script(pkg_dir, '__main__')
346 self._check_script(["-m", "test_pkg"], script_name,
347 script_name, script_dir, 'test_pkg',
348 importlib.machinery.SourceFileLoader,
349 cwd=script_dir)
350
351 def test_package_compiled(self):
352 with os_helper.temp_dir() as script_dir:
353 pkg_dir = os.path.join(script_dir, 'test_pkg')
354 make_pkg(pkg_dir)
355 script_name = _make_test_script(pkg_dir, '__main__')
356 compiled_name = py_compile.compile(script_name, doraise=True)
357 os.remove(script_name)
358 pyc_file = import_helper.make_legacy_pyc(script_name)
359 self._check_script(["-m", "test_pkg"], pyc_file,
360 pyc_file, script_dir, 'test_pkg',
361 importlib.machinery.SourcelessFileLoader,
362 cwd=script_dir)
363
364 def test_package_error(self):
365 with os_helper.temp_dir() as script_dir:
366 pkg_dir = os.path.join(script_dir, 'test_pkg')
367 make_pkg(pkg_dir)
368 msg = ("'test_pkg' is a package and cannot "
369 "be directly executed")
370 self._check_import_error(["-m", "test_pkg"], msg, cwd=script_dir)
371
372 def test_package_recursion(self):
373 with os_helper.temp_dir() as script_dir:
374 pkg_dir = os.path.join(script_dir, 'test_pkg')
375 make_pkg(pkg_dir)
376 main_dir = os.path.join(pkg_dir, '__main__')
377 make_pkg(main_dir)
378 msg = ("Cannot use package as __main__ module; "
379 "'test_pkg' is a package and cannot "
380 "be directly executed")
381 self._check_import_error(["-m", "test_pkg"], msg, cwd=script_dir)
382
383 def test_issue8202(self):
384 # Make sure package __init__ modules see "-m" in sys.argv0 while
385 # searching for the module to execute
386 with os_helper.temp_dir() as script_dir:
387 with os_helper.change_cwd(path=script_dir):
388 pkg_dir = os.path.join(script_dir, 'test_pkg')
389 make_pkg(pkg_dir, "import sys; print('init_argv0==%r' % sys.argv[0])")
390 script_name = _make_test_script(pkg_dir, 'script')
391 rc, out, err = assert_python_ok('-m', 'test_pkg.script', *example_args, __isolated=False)
392 if verbose > 1:
393 print(repr(out))
394 expected = "init_argv0==%r" % '-m'
395 self.assertIn(expected.encode('utf-8'), out)
396 self._check_output(script_name, rc, out,
397 script_name, script_name, script_dir, 'test_pkg',
398 importlib.machinery.SourceFileLoader)
399
400 def test_issue8202_dash_c_file_ignored(self):
401 # Make sure a "-c" file in the current directory
402 # does not alter the value of sys.path[0]
403 with os_helper.temp_dir() as script_dir:
404 with os_helper.change_cwd(path=script_dir):
405 with open("-c", "w", encoding="utf-8") as f:
406 f.write("data")
407 rc, out, err = assert_python_ok('-c',
408 'import sys; print("sys.path[0]==%r" % sys.path[0])',
409 __isolated=False)
410 if verbose > 1:
411 print(repr(out))
412 expected = "sys.path[0]==%r" % ''
413 self.assertIn(expected.encode('utf-8'), out)
414
415 def test_issue8202_dash_m_file_ignored(self):
416 # Make sure a "-m" file in the current directory
417 # does not alter the value of sys.path[0]
418 with os_helper.temp_dir() as script_dir:
419 script_name = _make_test_script(script_dir, 'other')
420 with os_helper.change_cwd(path=script_dir):
421 with open("-m", "w", encoding="utf-8") as f:
422 f.write("data")
423 rc, out, err = assert_python_ok('-m', 'other', *example_args,
424 __isolated=False)
425 self._check_output(script_name, rc, out,
426 script_name, script_name, script_dir, '',
427 importlib.machinery.SourceFileLoader)
428
429 def test_issue20884(self):
430 # On Windows, script with encoding cookie and LF line ending
431 # will be failed.
432 with os_helper.temp_dir() as script_dir:
433 script_name = os.path.join(script_dir, "issue20884.py")
434 with open(script_name, "w", encoding="latin1", newline='\n') as f:
435 f.write("#coding: iso-8859-1\n")
436 f.write('"""\n')
437 for _ in range(30):
438 f.write('x'*80 + '\n')
439 f.write('"""\n')
440
441 with os_helper.change_cwd(path=script_dir):
442 rc, out, err = assert_python_ok(script_name)
443 self.assertEqual(b"", out)
444 self.assertEqual(b"", err)
445
446 @contextlib.contextmanager
447 def setup_test_pkg(self, *args):
448 with os_helper.temp_dir() as script_dir, \
449 os_helper.change_cwd(path=script_dir):
450 pkg_dir = os.path.join(script_dir, 'test_pkg')
451 make_pkg(pkg_dir, *args)
452 yield pkg_dir
453
454 def check_dash_m_failure(self, *args):
455 rc, out, err = assert_python_failure('-m', *args, __isolated=False)
456 if verbose > 1:
457 print(repr(out))
458 self.assertEqual(rc, 1)
459 return err
460
461 def test_dash_m_error_code_is_one(self):
462 # If a module is invoked with the -m command line flag
463 # and results in an error that the return code to the
464 # shell is '1'
465 with self.setup_test_pkg() as pkg_dir:
466 script_name = _make_test_script(pkg_dir, 'other',
467 "if __name__ == '__main__': raise ValueError")
468 err = self.check_dash_m_failure('test_pkg.other', *example_args)
469 self.assertIn(b'ValueError', err)
470
471 def test_dash_m_errors(self):
472 # Exercise error reporting for various invalid package executions
473 tests = (
474 ('builtins', br'No code object available'),
475 ('builtins.x', br'Error while finding module specification.*'
476 br'ModuleNotFoundError'),
477 ('builtins.x.y', br'Error while finding module specification.*'
478 br'ModuleNotFoundError.*No module named.*not a package'),
479 ('importlib', br'No module named.*'
480 br'is a package and cannot be directly executed'),
481 ('importlib.nonexistent', br'No module named'),
482 ('.unittest', br'Relative module names not supported'),
483 )
484 for name, regex in tests:
485 with self.subTest(name):
486 rc, _, err = assert_python_failure('-m', name)
487 self.assertEqual(rc, 1)
488 self.assertRegex(err, regex)
489 self.assertNotIn(b'Traceback', err)
490
491 def test_dash_m_bad_pyc(self):
492 with os_helper.temp_dir() as script_dir, \
493 os_helper.change_cwd(path=script_dir):
494 os.mkdir('test_pkg')
495 # Create invalid *.pyc as empty file
496 with open('test_pkg/__init__.pyc', 'wb'):
497 pass
498 err = self.check_dash_m_failure('test_pkg')
499 self.assertRegex(err,
500 br'Error while finding module specification.*'
501 br'ImportError.*bad magic number')
502 self.assertNotIn(b'is a package', err)
503 self.assertNotIn(b'Traceback', err)
504
505 def test_hint_when_triying_to_import_a_py_file(self):
506 with os_helper.temp_dir() as script_dir, \
507 os_helper.change_cwd(path=script_dir):
508 # Create invalid *.pyc as empty file
509 with open('asyncio.py', 'wb'):
510 pass
511 err = self.check_dash_m_failure('asyncio.py')
512 self.assertIn(b"Try using 'asyncio' instead "
513 b"of 'asyncio.py' as the module name", err)
514
515 def test_dash_m_init_traceback(self):
516 # These were wrapped in an ImportError and tracebacks were
517 # suppressed; see Issue 14285
518 exceptions = (ImportError, AttributeError, TypeError, ValueError)
519 for exception in exceptions:
520 exception = exception.__name__
521 init = "raise {0}('Exception in __init__.py')".format(exception)
522 with self.subTest(exception), \
523 self.setup_test_pkg(init) as pkg_dir:
524 err = self.check_dash_m_failure('test_pkg')
525 self.assertIn(exception.encode('ascii'), err)
526 self.assertIn(b'Exception in __init__.py', err)
527 self.assertIn(b'Traceback', err)
528
529 def test_dash_m_main_traceback(self):
530 # Ensure that an ImportError's traceback is reported
531 with self.setup_test_pkg() as pkg_dir:
532 main = "raise ImportError('Exception in __main__ module')"
533 _make_test_script(pkg_dir, '__main__', main)
534 err = self.check_dash_m_failure('test_pkg')
535 self.assertIn(b'ImportError', err)
536 self.assertIn(b'Exception in __main__ module', err)
537 self.assertIn(b'Traceback', err)
538
539 def test_pep_409_verbiage(self):
540 # Make sure PEP 409 syntax properly suppresses
541 # the context of an exception
542 script = textwrap.dedent("""\
543 try:
544 raise ValueError
545 except:
546 raise NameError from None
547 """)
548 with os_helper.temp_dir() as script_dir:
549 script_name = _make_test_script(script_dir, 'script', script)
550 exitcode, stdout, stderr = assert_python_failure(script_name)
551 text = stderr.decode('ascii').split('\n')
552 self.assertEqual(len(text), 5)
553 self.assertTrue(text[0].startswith('Traceback'))
554 self.assertTrue(text[1].startswith(' File '))
555 self.assertTrue(text[3].startswith('NameError'))
556
557 def test_non_ascii(self):
558 # Mac OS X denies the creation of a file with an invalid UTF-8 name.
559 # Windows allows creating a name with an arbitrary bytes name, but
560 # Python cannot a undecodable bytes argument to a subprocess.
561 # WASI does not permit invalid UTF-8 names.
562 if (os_helper.TESTFN_UNDECODABLE
563 and sys.platform not in ('win32', 'darwin', 'emscripten', 'wasi')):
564 name = os.fsdecode(os_helper.TESTFN_UNDECODABLE)
565 elif os_helper.TESTFN_NONASCII:
566 name = os_helper.TESTFN_NONASCII
567 else:
568 self.skipTest("need os_helper.TESTFN_NONASCII")
569
570 # Issue #16218
571 source = 'print(ascii(__file__))\n'
572 script_name = _make_test_script(os.getcwd(), name, source)
573 self.addCleanup(os_helper.unlink, script_name)
574 rc, stdout, stderr = assert_python_ok(script_name)
575 self.assertEqual(
576 ascii(script_name),
577 stdout.rstrip().decode('ascii'),
578 'stdout=%r stderr=%r' % (stdout, stderr))
579 self.assertEqual(0, rc)
580
581 def test_issue20500_exit_with_exception_value(self):
582 script = textwrap.dedent("""\
583 import sys
584 error = None
585 try:
586 raise ValueError('some text')
587 except ValueError as err:
588 error = err
589
590 if error:
591 sys.exit(error)
592 """)
593 with os_helper.temp_dir() as script_dir:
594 script_name = _make_test_script(script_dir, 'script', script)
595 exitcode, stdout, stderr = assert_python_failure(script_name)
596 text = stderr.decode('ascii')
597 self.assertEqual(text.rstrip(), "some text")
598
599 def test_syntaxerror_unindented_caret_position(self):
600 script = "1 + 1 = 2\n"
601 with os_helper.temp_dir() as script_dir:
602 script_name = _make_test_script(script_dir, 'script', script)
603 exitcode, stdout, stderr = assert_python_failure(script_name)
604 text = io.TextIOWrapper(io.BytesIO(stderr), 'ascii').read()
605 # Confirm that the caret is located under the '=' sign
606 self.assertIn("\n ^^^^^\n", text)
607
608 def test_syntaxerror_indented_caret_position(self):
609 script = textwrap.dedent("""\
610 if True:
611 1 + 1 = 2
612 """)
613 with os_helper.temp_dir() as script_dir:
614 script_name = _make_test_script(script_dir, 'script', script)
615 exitcode, stdout, stderr = assert_python_failure(script_name)
616 text = io.TextIOWrapper(io.BytesIO(stderr), 'ascii').read()
617 # Confirm that the caret starts under the first 1 character
618 self.assertIn("\n 1 + 1 = 2\n ^^^^^\n", text)
619
620 # Try the same with a form feed at the start of the indented line
621 script = (
622 "if True:\n"
623 "\f 1 + 1 = 2\n"
624 )
625 script_name = _make_test_script(script_dir, "script", script)
626 exitcode, stdout, stderr = assert_python_failure(script_name)
627 text = io.TextIOWrapper(io.BytesIO(stderr), "ascii").read()
628 self.assertNotIn("\f", text)
629 self.assertIn("\n 1 + 1 = 2\n ^^^^^\n", text)
630
631 def test_syntaxerror_multi_line_fstring(self):
632 script = 'foo = f"""{}\nfoo"""\n'
633 with os_helper.temp_dir() as script_dir:
634 script_name = _make_test_script(script_dir, 'script', script)
635 exitcode, stdout, stderr = assert_python_failure(script_name)
636 self.assertEqual(
637 stderr.splitlines()[-3:],
638 [
639 b' foo"""',
640 b' ^',
641 b'SyntaxError: f-string: empty expression not allowed',
642 ],
643 )
644
645 def test_syntaxerror_invalid_escape_sequence_multi_line(self):
646 script = 'foo = """\\q"""\n'
647 with os_helper.temp_dir() as script_dir:
648 script_name = _make_test_script(script_dir, 'script', script)
649 exitcode, stdout, stderr = assert_python_failure(
650 '-Werror', script_name,
651 )
652 self.assertEqual(
653 stderr.splitlines()[-3:],
654 [ b' foo = """\\q"""',
655 b' ^^^^^^^^',
656 b'SyntaxError: invalid escape sequence \'\\q\''
657 ],
658 )
659
660 def test_syntaxerror_null_bytes(self):
661 script = "x = '\0' nothing to see here\n';import os;os.system('echo pwnd')\n"
662 with os_helper.temp_dir() as script_dir:
663 script_name = _make_test_script(script_dir, 'script', script)
664 exitcode, stdout, stderr = assert_python_failure(script_name)
665 self.assertEqual(
666 stderr.splitlines()[-2:],
667 [ b" x = '",
668 b'SyntaxError: source code cannot contain null bytes'
669 ],
670 )
671
672 def test_syntaxerror_null_bytes_in_multiline_string(self):
673 scripts = ["\n'''\nmultilinestring\0\n'''", "\nf'''\nmultilinestring\0\n'''"] # Both normal and f-strings
674 with os_helper.temp_dir() as script_dir:
675 for script in scripts:
676 script_name = _make_test_script(script_dir, 'script', script)
677 _, _, stderr = assert_python_failure(script_name)
678 self.assertEqual(
679 stderr.splitlines()[-2:],
680 [ b" multilinestring",
681 b'SyntaxError: source code cannot contain null bytes'
682 ]
683 )
684
685 def test_consistent_sys_path_for_direct_execution(self):
686 # This test case ensures that the following all give the same
687 # sys.path configuration:
688 #
689 # ./python -s script_dir/__main__.py
690 # ./python -s script_dir
691 # ./python -I script_dir
692 script = textwrap.dedent("""\
693 import sys
694 for entry in sys.path:
695 print(entry)
696 """)
697 # Always show full path diffs on errors
698 self.maxDiff = None
699 with os_helper.temp_dir() as work_dir, os_helper.temp_dir() as script_dir:
700 script_name = _make_test_script(script_dir, '__main__', script)
701 # Reference output comes from directly executing __main__.py
702 # We omit PYTHONPATH and user site to align with isolated mode
703 p = spawn_python("-Es", script_name, cwd=work_dir)
704 out_by_name = kill_python(p).decode().splitlines()
705 self.assertEqual(out_by_name[0], script_dir)
706 self.assertNotIn(work_dir, out_by_name)
707 # Directory execution should give the same output
708 p = spawn_python("-Es", script_dir, cwd=work_dir)
709 out_by_dir = kill_python(p).decode().splitlines()
710 self.assertEqual(out_by_dir, out_by_name)
711 # As should directory execution in isolated mode
712 p = spawn_python("-I", script_dir, cwd=work_dir)
713 out_by_dir_isolated = kill_python(p).decode().splitlines()
714 self.assertEqual(out_by_dir_isolated, out_by_dir, out_by_name)
715
716 def test_consistent_sys_path_for_module_execution(self):
717 # This test case ensures that the following both give the same
718 # sys.path configuration:
719 # ./python -sm script_pkg.__main__
720 # ./python -sm script_pkg
721 #
722 # And that this fails as unable to find the package:
723 # ./python -Im script_pkg
724 script = textwrap.dedent("""\
725 import sys
726 for entry in sys.path:
727 print(entry)
728 """)
729 # Always show full path diffs on errors
730 self.maxDiff = None
731 with os_helper.temp_dir() as work_dir:
732 script_dir = os.path.join(work_dir, "script_pkg")
733 os.mkdir(script_dir)
734 script_name = _make_test_script(script_dir, '__main__', script)
735 # Reference output comes from `-m script_pkg.__main__`
736 # We omit PYTHONPATH and user site to better align with the
737 # direct execution test cases
738 p = spawn_python("-sm", "script_pkg.__main__", cwd=work_dir)
739 out_by_module = kill_python(p).decode().splitlines()
740 self.assertEqual(out_by_module[0], work_dir)
741 self.assertNotIn(script_dir, out_by_module)
742 # Package execution should give the same output
743 p = spawn_python("-sm", "script_pkg", cwd=work_dir)
744 out_by_package = kill_python(p).decode().splitlines()
745 self.assertEqual(out_by_package, out_by_module)
746 # Isolated mode should fail with an import error
747 exitcode, stdout, stderr = assert_python_failure(
748 "-Im", "script_pkg", cwd=work_dir
749 )
750 traceback_lines = stderr.decode().splitlines()
751 self.assertIn("No module named script_pkg", traceback_lines[-1])
752
753 def test_nonexisting_script(self):
754 # bpo-34783: "./python script.py" must not crash
755 # if the script file doesn't exist.
756 # (Skip test for macOS framework builds because sys.executable name
757 # is not the actual Python executable file name.
758 script = 'nonexistingscript.py'
759 self.assertFalse(os.path.exists(script))
760
761 proc = spawn_python(script, text=True,
762 stdout=subprocess.PIPE,
763 stderr=subprocess.PIPE)
764 out, err = proc.communicate()
765 self.assertIn(": can't open file ", err)
766 self.assertNotEqual(proc.returncode, 0)
767
768 @unittest.skipUnless(os.path.exists('/dev/fd/0'), 'requires /dev/fd platform')
769 @unittest.skipIf(sys.platform.startswith("freebsd") and
770 os.stat("/dev").st_dev == os.stat("/dev/fd").st_dev,
771 "Requires fdescfs mounted on /dev/fd on FreeBSD")
772 def test_script_as_dev_fd(self):
773 # GH-87235: On macOS passing a non-trivial script to /dev/fd/N can cause
774 # problems because all open /dev/fd/N file descriptors share the same
775 # offset.
776 script = 'print("12345678912345678912345")'
777 with os_helper.temp_dir() as work_dir:
778 script_name = _make_test_script(work_dir, 'script.py', script)
779 with open(script_name, "r") as fp:
780 p = spawn_python(f"/dev/fd/{fp.fileno()}", close_fds=True, pass_fds=(0,1,2,fp.fileno()))
781 out, err = p.communicate()
782 self.assertEqual(out, b"12345678912345678912345\n")
783
784
785
786 def tearDownModule():
787 support.reap_children()
788
789
790 if __name__ == '__main__':
791 unittest.main()