2014-04-02 15:31:39 +01:00
|
|
|
#! /usr/bin/env python3
|
2014-01-27 21:53:28 +00:00
|
|
|
|
|
|
|
import os
|
|
|
|
import subprocess
|
|
|
|
import sys
|
2014-09-17 22:56:34 +01:00
|
|
|
import platform
|
2014-05-03 16:43:27 +01:00
|
|
|
import argparse
|
2020-04-08 07:01:58 +01:00
|
|
|
import inspect
|
2015-03-20 17:25:25 +00:00
|
|
|
import re
|
2014-01-27 21:53:28 +00:00
|
|
|
from glob import glob
|
2021-05-11 14:24:36 +01:00
|
|
|
import multiprocessing
|
|
|
|
from multiprocessing.pool import ThreadPool
|
|
|
|
import threading
|
|
|
|
import tempfile
|
2014-01-27 21:53:28 +00:00
|
|
|
|
2022-04-21 01:54:02 +01:00
|
|
|
# Maximum time to run a PC-based test, in seconds.
|
|
|
|
TEST_TIMEOUT = 30
|
|
|
|
|
2020-04-08 07:01:58 +01:00
|
|
|
# See stackoverflow.com/questions/2632199: __file__ nor sys.argv[0]
|
|
|
|
# are guaranteed to always work, this one should though.
|
|
|
|
BASEPATH = os.path.dirname(os.path.abspath(inspect.getsourcefile(lambda: None)))
|
|
|
|
|
2021-03-11 05:11:27 +00:00
|
|
|
|
2020-04-08 07:01:58 +01:00
|
|
|
def base_path(*p):
|
|
|
|
return os.path.abspath(os.path.join(BASEPATH, *p)).replace("\\", "/")
|
2021-03-11 05:11:27 +00:00
|
|
|
|
2020-04-08 07:01:58 +01:00
|
|
|
|
2014-04-04 15:28:34 +01:00
|
|
|
# Tests require at least CPython 3.3. If your default python3 executable
|
|
|
|
# is of lower version, you can point MICROPY_CPYTHON3 environment var
|
|
|
|
# to the correct executable.
|
2014-01-27 21:53:28 +00:00
|
|
|
if os.name == "nt":
|
2021-01-14 12:23:15 +00:00
|
|
|
CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python")
|
2022-11-29 15:58:21 +00:00
|
|
|
MICROPYTHON = os.getenv(
|
|
|
|
"MICROPY_MICROPYTHON", base_path("../ports/windows/build-standard/micropython.exe")
|
|
|
|
)
|
2022-08-03 15:29:55 +01:00
|
|
|
# mpy-cross is only needed if --via-mpy command-line arg is passed
|
2022-11-29 15:58:21 +00:00
|
|
|
MPYCROSS = os.getenv("MICROPY_MPYCROSS", base_path("../mpy-cross/build/mpy-cross.exe"))
|
2014-01-27 21:53:28 +00:00
|
|
|
else:
|
2014-04-03 20:06:35 +01:00
|
|
|
CPYTHON3 = os.getenv("MICROPY_CPYTHON3", "python3")
|
2022-08-02 22:48:41 +01:00
|
|
|
MICROPYTHON = os.getenv(
|
|
|
|
"MICROPY_MICROPYTHON", base_path("../ports/unix/build-standard/micropython")
|
|
|
|
)
|
2022-08-03 15:29:55 +01:00
|
|
|
# mpy-cross is only needed if --via-mpy command-line arg is passed
|
|
|
|
MPYCROSS = os.getenv("MICROPY_MPYCROSS", base_path("../mpy-cross/build/mpy-cross"))
|
2014-01-27 21:53:28 +00:00
|
|
|
|
2020-09-24 03:03:30 +01:00
|
|
|
# Use CPython options to not save .pyc files, to only access the core standard library
|
|
|
|
# (not site packages which may clash with u-module names), and improve start up time.
|
|
|
|
CPYTHON3_CMD = [CPYTHON3, "-BS"]
|
|
|
|
|
2016-09-20 03:19:35 +01:00
|
|
|
|
2020-03-30 09:14:09 +01:00
|
|
|
# For diff'ing test output
|
|
|
|
DIFF = os.getenv("MICROPY_DIFF", "diff -u")
|
|
|
|
|
2014-11-19 15:44:31 +00:00
|
|
|
# Set PYTHONIOENCODING so that CPython will use utf-8 on systems which set another encoding in the locale
|
2014-12-11 22:51:39 +00:00
|
|
|
os.environ["PYTHONIOENCODING"] = "utf-8"
|
2021-03-11 05:11:27 +00:00
|
|
|
|
2022-05-19 05:54:06 +01:00
|
|
|
# Code to allow a target MicroPython to import an .mpy from RAM
|
|
|
|
injected_import_hook_code = """\
|
|
|
|
import usys, uos, uio
|
|
|
|
class __File(uio.IOBase):
|
|
|
|
def __init__(self):
|
|
|
|
self.off = 0
|
|
|
|
def ioctl(self, request, arg):
|
|
|
|
return 0
|
|
|
|
def readinto(self, buf):
|
|
|
|
buf[:] = memoryview(__buf)[self.off:self.off + len(buf)]
|
|
|
|
self.off += len(buf)
|
|
|
|
return len(buf)
|
|
|
|
class __FS:
|
|
|
|
def mount(self, readonly, mkfs):
|
|
|
|
pass
|
|
|
|
def umount(self):
|
|
|
|
pass
|
|
|
|
def chdir(self, path):
|
|
|
|
pass
|
|
|
|
def stat(self, path):
|
|
|
|
if path == '__injected_test.mpy':
|
|
|
|
return tuple(0 for _ in range(10))
|
|
|
|
else:
|
|
|
|
raise OSError(-2) # ENOENT
|
|
|
|
def open(self, path, mode):
|
|
|
|
return __File()
|
|
|
|
uos.mount(__FS(), '/__vfstest')
|
|
|
|
uos.chdir('/__vfstest')
|
|
|
|
__import__('__injected_test')
|
|
|
|
"""
|
|
|
|
|
2014-11-19 15:44:31 +00:00
|
|
|
|
2014-03-22 23:07:30 +00:00
|
|
|
def rm_f(fname):
|
|
|
|
if os.path.exists(fname):
|
|
|
|
os.remove(fname)
|
|
|
|
|
2016-07-26 19:29:48 +01:00
|
|
|
|
|
|
|
# unescape wanted regex chars and escape unwanted ones
|
|
|
|
def convert_regex_escapes(line):
|
|
|
|
cs = []
|
|
|
|
escape = False
|
|
|
|
for c in str(line, "utf8"):
|
|
|
|
if escape:
|
|
|
|
escape = False
|
|
|
|
cs.append(c)
|
|
|
|
elif c == "\\":
|
|
|
|
escape = True
|
|
|
|
elif c in ("(", ")", "[", "]", "{", "}", ".", "*", "+", "^", "$"):
|
|
|
|
cs.append("\\" + c)
|
|
|
|
else:
|
|
|
|
cs.append(c)
|
|
|
|
# accept carriage-return(s) before final newline
|
|
|
|
if cs[-1] == "\n":
|
|
|
|
cs[-1] = "\r*\n"
|
|
|
|
return bytes("".join(cs), "utf8")
|
|
|
|
|
|
|
|
|
2022-05-19 05:54:06 +01:00
|
|
|
def prepare_script_for_target(args, *, script_filename=None, script_text=None, force_plain=False):
|
|
|
|
if force_plain or (not args.via_mpy and args.emit == "bytecode"):
|
|
|
|
if script_filename is not None:
|
|
|
|
with open(script_filename, "rb") as f:
|
|
|
|
script_text = f.read()
|
|
|
|
elif args.via_mpy:
|
|
|
|
tempname = tempfile.mktemp(dir="")
|
|
|
|
mpy_filename = tempname + ".mpy"
|
|
|
|
|
|
|
|
if script_filename is None:
|
|
|
|
script_filename = tempname + ".py"
|
|
|
|
cleanup_script_filename = True
|
|
|
|
with open(script_filename, "wb") as f:
|
|
|
|
f.write(script_text)
|
|
|
|
else:
|
|
|
|
cleanup_script_filename = False
|
|
|
|
|
2022-05-23 02:10:37 +01:00
|
|
|
try:
|
|
|
|
subprocess.check_output(
|
|
|
|
[MPYCROSS]
|
|
|
|
+ args.mpy_cross_flags.split()
|
|
|
|
+ ["-o", mpy_filename, "-X", "emit=" + args.emit, script_filename],
|
|
|
|
stderr=subprocess.STDOUT,
|
|
|
|
)
|
|
|
|
except subprocess.CalledProcessError as er:
|
|
|
|
return True, b"mpy-cross crash\n" + er.output
|
2022-05-19 05:54:06 +01:00
|
|
|
|
|
|
|
with open(mpy_filename, "rb") as f:
|
|
|
|
script_text = b"__buf=" + bytes(repr(f.read()), "ascii") + b"\n"
|
|
|
|
|
|
|
|
rm_f(mpy_filename)
|
|
|
|
if cleanup_script_filename:
|
|
|
|
rm_f(script_filename)
|
|
|
|
|
|
|
|
script_text += bytes(injected_import_hook_code, "ascii")
|
|
|
|
else:
|
|
|
|
print("error: using emit={} must go via .mpy".format(args.emit))
|
|
|
|
sys.exit(1)
|
|
|
|
|
2022-05-23 02:10:37 +01:00
|
|
|
return False, script_text
|
2022-05-19 05:54:06 +01:00
|
|
|
|
|
|
|
|
|
|
|
def run_script_on_remote_target(pyb, args, test_file, is_special):
|
2022-05-23 02:10:37 +01:00
|
|
|
had_crash, script = prepare_script_for_target(
|
|
|
|
args, script_filename=test_file, force_plain=is_special
|
|
|
|
)
|
|
|
|
if had_crash:
|
|
|
|
return True, script
|
|
|
|
|
2022-05-19 05:54:06 +01:00
|
|
|
try:
|
|
|
|
had_crash = False
|
|
|
|
pyb.enter_raw_repl()
|
|
|
|
output_mupy = pyb.exec_(script)
|
|
|
|
except pyboard.PyboardError as e:
|
|
|
|
had_crash = True
|
|
|
|
if not is_special and e.args[0] == "exception":
|
|
|
|
output_mupy = e.args[1] + e.args[2] + b"CRASH"
|
|
|
|
else:
|
|
|
|
output_mupy = bytes(e.args[0], "ascii") + b"\nCRASH"
|
|
|
|
return had_crash, output_mupy
|
|
|
|
|
|
|
|
|
2017-04-14 15:07:13 +01:00
|
|
|
def run_micropython(pyb, args, test_file, is_special=False):
|
2017-12-04 23:52:41 +00:00
|
|
|
special_tests = (
|
|
|
|
"micropython/meminfo.py",
|
|
|
|
"basics/bytes_compare3.py",
|
|
|
|
"basics/builtin_help.py",
|
|
|
|
"thread/thread_exc2.py",
|
2020-04-02 06:59:08 +01:00
|
|
|
"esp32/partition_ota.py",
|
2017-12-04 23:52:41 +00:00
|
|
|
)
|
2018-02-14 06:19:44 +00:00
|
|
|
had_crash = False
|
2014-10-05 22:27:12 +01:00
|
|
|
if pyb is None:
|
|
|
|
# run on PC
|
2020-04-08 07:01:58 +01:00
|
|
|
if (
|
|
|
|
test_file.startswith(("cmdline/", base_path("feature_check/")))
|
|
|
|
or test_file in special_tests
|
|
|
|
):
|
2015-03-13 10:58:34 +00:00
|
|
|
# special handling for tests of the unix cmdline program
|
2016-07-26 19:29:48 +01:00
|
|
|
is_special = True
|
2015-03-13 10:58:34 +00:00
|
|
|
|
2017-04-14 15:07:13 +01:00
|
|
|
if is_special:
|
2015-03-13 10:58:34 +00:00
|
|
|
# check for any cmdline options needed for this test
|
|
|
|
args = [MICROPYTHON]
|
|
|
|
with open(test_file, "rb") as f:
|
|
|
|
line = f.readline()
|
|
|
|
if line.startswith(b"# cmdline:"):
|
2015-08-06 11:34:48 +01:00
|
|
|
# subprocess.check_output on Windows only accepts strings, not bytes
|
|
|
|
args += [str(c, "utf-8") for c in line[10:].strip().split()]
|
2015-03-13 10:58:34 +00:00
|
|
|
|
|
|
|
# run the test, possibly with redirected input
|
|
|
|
try:
|
2015-08-30 09:36:42 +01:00
|
|
|
if "repl_" in test_file:
|
2015-07-23 20:05:30 +01:00
|
|
|
# Need to use a PTY to test command line editing
|
2015-08-06 11:34:48 +01:00
|
|
|
try:
|
|
|
|
import pty
|
|
|
|
except ImportError:
|
|
|
|
# in case pty module is not available, like on Windows
|
|
|
|
return b"SKIP\n"
|
2015-07-23 20:05:30 +01:00
|
|
|
import select
|
|
|
|
|
2022-02-17 09:51:17 +00:00
|
|
|
# Even though these might have the pty module, it's unlikely to function.
|
|
|
|
if sys.platform in ["win32", "msys", "cygwin"]:
|
|
|
|
return b"SKIP\n"
|
|
|
|
|
2015-11-24 17:52:03 +00:00
|
|
|
def get(required=False):
|
2015-07-23 20:05:30 +01:00
|
|
|
rv = b""
|
|
|
|
while True:
|
|
|
|
ready = select.select([master], [], [], 0.02)
|
|
|
|
if ready[0] == [master]:
|
|
|
|
rv += os.read(master, 1024)
|
|
|
|
else:
|
2015-11-24 17:52:03 +00:00
|
|
|
if not required or rv:
|
|
|
|
return rv
|
2015-07-23 20:05:30 +01:00
|
|
|
|
|
|
|
def send_get(what):
|
|
|
|
os.write(master, what)
|
|
|
|
return get()
|
|
|
|
|
|
|
|
with open(test_file, "rb") as f:
|
|
|
|
# instead of: output_mupy = subprocess.check_output(args, stdin=f)
|
|
|
|
master, slave = pty.openpty()
|
|
|
|
p = subprocess.Popen(
|
|
|
|
args, stdin=slave, stdout=slave, stderr=subprocess.STDOUT, bufsize=0
|
|
|
|
)
|
2015-11-24 17:52:03 +00:00
|
|
|
banner = get(True)
|
2015-07-23 20:05:30 +01:00
|
|
|
output_mupy = banner + b"".join(send_get(line) for line in f)
|
2016-12-20 04:13:49 +00:00
|
|
|
send_get(b"\x04") # exit the REPL, so coverage info is saved
|
2019-03-31 08:47:11 +01:00
|
|
|
# At this point the process might have exited already, but trying to
|
|
|
|
# kill it 'again' normally doesn't result in exceptions as Python and/or
|
|
|
|
# the OS seem to try to handle this nicely. When running Linux on WSL
|
|
|
|
# though, the situation differs and calling Popen.kill after the process
|
|
|
|
# terminated results in a ProcessLookupError. Just catch that one here
|
|
|
|
# since we just want the process to be gone and that's the case.
|
|
|
|
try:
|
|
|
|
p.kill()
|
|
|
|
except ProcessLookupError:
|
|
|
|
pass
|
2015-07-23 20:05:30 +01:00
|
|
|
os.close(master)
|
|
|
|
os.close(slave)
|
2015-03-13 10:58:34 +00:00
|
|
|
else:
|
2017-09-25 02:15:48 +01:00
|
|
|
output_mupy = subprocess.check_output(
|
|
|
|
args + [test_file], stderr=subprocess.STDOUT
|
|
|
|
)
|
2015-03-13 10:58:34 +00:00
|
|
|
except subprocess.CalledProcessError:
|
2015-09-21 11:24:17 +01:00
|
|
|
return b"CRASH"
|
2015-03-13 10:58:34 +00:00
|
|
|
|
|
|
|
else:
|
2016-09-20 03:19:35 +01:00
|
|
|
# a standard test run on PC
|
|
|
|
|
|
|
|
# create system command
|
|
|
|
cmdlist = [MICROPYTHON, "-X", "emit=" + args.emit]
|
|
|
|
if args.heapsize is not None:
|
|
|
|
cmdlist.extend(["-X", "heapsize=" + args.heapsize])
|
2022-05-21 01:45:07 +01:00
|
|
|
if sys.platform == "darwin":
|
|
|
|
cmdlist.extend(["-X", "realtime"])
|
2016-09-20 03:19:35 +01:00
|
|
|
|
|
|
|
# if running via .mpy, first compile the .py file
|
|
|
|
if args.via_mpy:
|
2021-05-11 14:24:36 +01:00
|
|
|
mpy_modname = tempfile.mktemp(dir="")
|
|
|
|
mpy_filename = mpy_modname + ".mpy"
|
2019-12-22 12:51:57 +00:00
|
|
|
subprocess.check_output(
|
|
|
|
[MPYCROSS]
|
|
|
|
+ args.mpy_cross_flags.split()
|
2021-05-11 14:24:36 +01:00
|
|
|
+ ["-o", mpy_filename, "-X", "emit=" + args.emit, test_file]
|
2019-12-22 12:51:57 +00:00
|
|
|
)
|
2021-05-11 14:24:36 +01:00
|
|
|
cmdlist.extend(["-m", mpy_modname])
|
2016-09-20 03:19:35 +01:00
|
|
|
else:
|
2016-03-15 13:04:43 +00:00
|
|
|
cmdlist.append(test_file)
|
2016-09-20 03:19:35 +01:00
|
|
|
|
|
|
|
# run the actual test
|
|
|
|
try:
|
2022-04-21 01:54:02 +01:00
|
|
|
output_mupy = subprocess.check_output(
|
|
|
|
cmdlist, stderr=subprocess.STDOUT, timeout=TEST_TIMEOUT
|
|
|
|
)
|
2018-02-14 06:19:44 +00:00
|
|
|
except subprocess.CalledProcessError as er:
|
|
|
|
had_crash = True
|
|
|
|
output_mupy = er.output + b"CRASH"
|
2022-04-21 01:54:02 +01:00
|
|
|
except subprocess.TimeoutExpired as er:
|
|
|
|
had_crash = True
|
|
|
|
output_mupy = (er.output or b"") + b"TIMEOUT"
|
2016-09-20 03:19:35 +01:00
|
|
|
|
|
|
|
# clean up if we had an intermediate .mpy file
|
|
|
|
if args.via_mpy:
|
2021-05-11 14:24:36 +01:00
|
|
|
rm_f(mpy_filename)
|
2016-09-20 03:19:35 +01:00
|
|
|
|
2014-10-05 22:27:12 +01:00
|
|
|
else:
|
2022-05-19 05:54:06 +01:00
|
|
|
# run via pyboard interface
|
|
|
|
had_crash, output_mupy = run_script_on_remote_target(pyb, args, test_file, is_special)
|
2014-10-05 22:27:12 +01:00
|
|
|
|
2016-03-07 12:01:21 +00:00
|
|
|
# canonical form for all ports/platforms is to use \n for end-of-line
|
|
|
|
output_mupy = output_mupy.replace(b"\r\n", b"\n")
|
|
|
|
|
2017-01-23 09:44:29 +00:00
|
|
|
# don't try to convert the output if we should skip this test
|
2018-02-14 06:19:44 +00:00
|
|
|
if had_crash or output_mupy in (b"SKIP\n", b"CRASH"):
|
2017-01-23 09:44:29 +00:00
|
|
|
return output_mupy
|
|
|
|
|
2022-08-15 03:02:23 +01:00
|
|
|
# skipped special tests will output "SKIP" surrounded by other interpreter debug output
|
|
|
|
if is_special and not had_crash and b"\nSKIP\n" in output_mupy:
|
|
|
|
return b"SKIP\n"
|
|
|
|
|
2016-07-26 19:29:48 +01:00
|
|
|
if is_special or test_file in special_tests:
|
|
|
|
# convert parts of the output that are not stable across runs
|
|
|
|
with open(test_file + ".exp", "rb") as f:
|
|
|
|
lines_exp = []
|
|
|
|
for line in f.readlines():
|
|
|
|
if line == b"########\n":
|
|
|
|
line = (line,)
|
|
|
|
else:
|
|
|
|
line = (line, re.compile(convert_regex_escapes(line)))
|
|
|
|
lines_exp.append(line)
|
|
|
|
lines_mupy = [line + b"\n" for line in output_mupy.split(b"\n")]
|
|
|
|
if output_mupy.endswith(b"\n"):
|
|
|
|
lines_mupy = lines_mupy[:-1] # remove erroneous last empty line
|
|
|
|
i_mupy = 0
|
|
|
|
for i in range(len(lines_exp)):
|
|
|
|
if lines_exp[i][0] == b"########\n":
|
|
|
|
# 8x #'s means match 0 or more whole lines
|
|
|
|
line_exp = lines_exp[i + 1]
|
|
|
|
skip = 0
|
|
|
|
while i_mupy + skip < len(lines_mupy) and not line_exp[1].match(
|
|
|
|
lines_mupy[i_mupy + skip]
|
|
|
|
):
|
|
|
|
skip += 1
|
|
|
|
if i_mupy + skip >= len(lines_mupy):
|
|
|
|
lines_mupy[i_mupy] = b"######## FAIL\n"
|
|
|
|
break
|
|
|
|
del lines_mupy[i_mupy : i_mupy + skip]
|
|
|
|
lines_mupy.insert(i_mupy, b"########\n")
|
|
|
|
i_mupy += 1
|
|
|
|
else:
|
|
|
|
# a regex
|
|
|
|
if lines_exp[i][1].match(lines_mupy[i_mupy]):
|
|
|
|
lines_mupy[i_mupy] = lines_exp[i][0]
|
|
|
|
else:
|
|
|
|
# print("don't match: %r %s" % (lines_exp[i][1], lines_mupy[i_mupy])) # DEBUG
|
|
|
|
pass
|
|
|
|
i_mupy += 1
|
|
|
|
if i_mupy >= len(lines_mupy):
|
|
|
|
break
|
|
|
|
output_mupy = b"".join(lines_mupy)
|
|
|
|
|
2014-10-05 22:27:12 +01:00
|
|
|
return output_mupy
|
|
|
|
|
2017-04-14 15:07:13 +01:00
|
|
|
|
|
|
|
def run_feature_check(pyb, args, base_path, test_file):
|
2020-05-09 07:20:40 +01:00
|
|
|
if pyb is not None and test_file.startswith("repl_"):
|
|
|
|
# REPL feature tests will not run via pyboard because they require prompt interactivity
|
|
|
|
return b""
|
2020-04-08 07:01:58 +01:00
|
|
|
return run_micropython(pyb, args, base_path("feature_check", test_file), is_special=True)
|
2017-04-14 15:07:13 +01:00
|
|
|
|
|
|
|
|
2021-05-11 14:24:36 +01:00
|
|
|
class ThreadSafeCounter:
|
|
|
|
def __init__(self, start=0):
|
|
|
|
self._value = start
|
|
|
|
self._lock = threading.Lock()
|
|
|
|
|
|
|
|
def increment(self):
|
|
|
|
self.add(1)
|
|
|
|
|
|
|
|
def add(self, to_add):
|
|
|
|
with self._lock:
|
|
|
|
self._value += to_add
|
|
|
|
|
|
|
|
def append(self, arg):
|
|
|
|
self.add([arg])
|
|
|
|
|
|
|
|
@property
|
|
|
|
def value(self):
|
|
|
|
return self._value
|
|
|
|
|
|
|
|
|
|
|
|
def run_tests(pyb, tests, args, result_dir, num_threads=1):
|
|
|
|
test_count = ThreadSafeCounter()
|
|
|
|
testcase_count = ThreadSafeCounter()
|
|
|
|
passed_count = ThreadSafeCounter()
|
|
|
|
failed_tests = ThreadSafeCounter([])
|
|
|
|
skipped_tests = ThreadSafeCounter([])
|
2014-05-03 16:43:27 +01:00
|
|
|
|
2014-06-05 22:45:55 +01:00
|
|
|
skip_tests = set()
|
2014-12-12 22:50:54 +00:00
|
|
|
skip_native = False
|
2017-03-03 17:14:02 +00:00
|
|
|
skip_int_big = False
|
2019-10-18 09:48:15 +01:00
|
|
|
skip_bytearray = False
|
2017-01-04 21:16:29 +00:00
|
|
|
skip_set_type = False
|
2019-10-29 10:44:22 +00:00
|
|
|
skip_slice = False
|
2017-02-14 19:03:25 +00:00
|
|
|
skip_async = False
|
2017-04-02 20:51:31 +01:00
|
|
|
skip_const = False
|
2017-09-10 15:05:31 +01:00
|
|
|
skip_revops = False
|
2019-10-29 11:13:38 +00:00
|
|
|
skip_io_module = False
|
2021-08-12 16:44:08 +01:00
|
|
|
skip_fstring = False
|
2017-12-15 10:07:09 +00:00
|
|
|
skip_endian = False
|
|
|
|
has_complex = True
|
|
|
|
has_coverage = False
|
|
|
|
|
|
|
|
upy_float_precision = 32
|
|
|
|
|
|
|
|
# If we're asked to --list-tests, we can't assume that there's a
|
|
|
|
# connection to target, so we can't run feature checks usefully.
|
|
|
|
if not (args.list_tests or args.write_exp):
|
2020-04-08 07:01:58 +01:00
|
|
|
# Even if we run completely different tests in a different directory,
|
|
|
|
# we need to access feature_checks from the same directory as the
|
2021-03-11 05:09:27 +00:00
|
|
|
# run-tests.py script itself so use base_path.
|
2020-04-08 07:01:58 +01:00
|
|
|
|
2017-12-15 10:07:09 +00:00
|
|
|
# Check if micropython.native is supported, and skip such tests if it's not
|
|
|
|
output = run_feature_check(pyb, args, base_path, "native_check.py")
|
2021-04-14 15:47:24 +01:00
|
|
|
if output != b"native\n":
|
2017-12-15 10:07:09 +00:00
|
|
|
skip_native = True
|
|
|
|
|
|
|
|
# Check if arbitrary-precision integers are supported, and skip such tests if it's not
|
|
|
|
output = run_feature_check(pyb, args, base_path, "int_big.py")
|
|
|
|
if output != b"1000000000000000000000000000000000000000000000\n":
|
|
|
|
skip_int_big = True
|
|
|
|
|
2019-10-18 09:48:15 +01:00
|
|
|
# Check if bytearray is supported, and skip such tests if it's not
|
|
|
|
output = run_feature_check(pyb, args, base_path, "bytearray.py")
|
|
|
|
if output != b"bytearray\n":
|
|
|
|
skip_bytearray = True
|
|
|
|
|
2017-12-15 10:07:09 +00:00
|
|
|
# Check if set type (and set literals) is supported, and skip such tests if it's not
|
|
|
|
output = run_feature_check(pyb, args, base_path, "set_check.py")
|
2021-04-14 15:47:24 +01:00
|
|
|
if output != b"{1}\n":
|
2017-12-15 10:07:09 +00:00
|
|
|
skip_set_type = True
|
|
|
|
|
2019-10-29 10:44:22 +00:00
|
|
|
# Check if slice is supported, and skip such tests if it's not
|
|
|
|
output = run_feature_check(pyb, args, base_path, "slice.py")
|
|
|
|
if output != b"slice\n":
|
|
|
|
skip_slice = True
|
|
|
|
|
2017-12-15 10:07:09 +00:00
|
|
|
# Check if async/await keywords are supported, and skip such tests if it's not
|
|
|
|
output = run_feature_check(pyb, args, base_path, "async_check.py")
|
2021-04-14 15:47:24 +01:00
|
|
|
if output != b"async\n":
|
2017-12-15 10:07:09 +00:00
|
|
|
skip_async = True
|
|
|
|
|
|
|
|
# Check if const keyword (MicroPython extension) is supported, and skip such tests if it's not
|
|
|
|
output = run_feature_check(pyb, args, base_path, "const.py")
|
2021-04-14 15:47:24 +01:00
|
|
|
if output != b"1\n":
|
2017-12-15 10:07:09 +00:00
|
|
|
skip_const = True
|
|
|
|
|
|
|
|
# Check if __rOP__ special methods are supported, and skip such tests if it's not
|
|
|
|
output = run_feature_check(pyb, args, base_path, "reverse_ops.py")
|
|
|
|
if output == b"TypeError\n":
|
|
|
|
skip_revops = True
|
|
|
|
|
2019-10-29 11:13:38 +00:00
|
|
|
# Check if uio module exists, and skip such tests if it doesn't
|
|
|
|
output = run_feature_check(pyb, args, base_path, "uio_module.py")
|
|
|
|
if output != b"uio\n":
|
|
|
|
skip_io_module = True
|
|
|
|
|
2021-08-12 16:44:08 +01:00
|
|
|
# Check if fstring feature is enabled, and skip such tests if it doesn't
|
|
|
|
output = run_feature_check(pyb, args, base_path, "fstring.py")
|
|
|
|
if output != b"a=1\n":
|
|
|
|
skip_fstring = True
|
|
|
|
|
2017-12-15 10:07:09 +00:00
|
|
|
# Check if emacs repl is supported, and skip such tests if it's not
|
|
|
|
t = run_feature_check(pyb, args, base_path, "repl_emacs_check.py")
|
2019-12-14 21:42:03 +00:00
|
|
|
if "True" not in str(t, "ascii"):
|
2017-12-15 10:07:09 +00:00
|
|
|
skip_tests.add("cmdline/repl_emacs_keys.py")
|
|
|
|
|
2019-12-14 21:42:03 +00:00
|
|
|
# Check if words movement in repl is supported, and skip such tests if it's not
|
|
|
|
t = run_feature_check(pyb, args, base_path, "repl_words_move_check.py")
|
|
|
|
if "True" not in str(t, "ascii"):
|
|
|
|
skip_tests.add("cmdline/repl_words_move.py")
|
|
|
|
|
2017-12-15 10:07:09 +00:00
|
|
|
upy_byteorder = run_feature_check(pyb, args, base_path, "byteorder.py")
|
2020-01-02 15:40:54 +00:00
|
|
|
upy_float_precision = run_feature_check(pyb, args, base_path, "float.py")
|
2021-04-14 15:47:24 +01:00
|
|
|
try:
|
2020-01-02 15:40:54 +00:00
|
|
|
upy_float_precision = int(upy_float_precision)
|
2021-04-14 15:47:24 +01:00
|
|
|
except ValueError:
|
|
|
|
upy_float_precision = 0
|
2017-12-15 10:07:09 +00:00
|
|
|
has_complex = run_feature_check(pyb, args, base_path, "complex.py") == b"complex\n"
|
|
|
|
has_coverage = run_feature_check(pyb, args, base_path, "coverage.py") == b"coverage\n"
|
2020-09-24 03:03:30 +01:00
|
|
|
cpy_byteorder = subprocess.check_output(
|
|
|
|
CPYTHON3_CMD + [base_path("feature_check/byteorder.py")]
|
2017-12-15 10:07:09 +00:00
|
|
|
)
|
|
|
|
skip_endian = upy_byteorder != cpy_byteorder
|
2015-08-29 22:28:59 +01:00
|
|
|
|
2019-10-29 11:01:17 +00:00
|
|
|
# These tests don't test slice explicitly but rather use it to perform the test
|
|
|
|
misc_slice_tests = (
|
|
|
|
"builtin_range",
|
|
|
|
"class_super",
|
|
|
|
"containment",
|
|
|
|
"errno1",
|
|
|
|
"fun_str",
|
|
|
|
"generator1",
|
|
|
|
"globals_del",
|
|
|
|
"memoryview1",
|
|
|
|
"memoryview_gc",
|
|
|
|
"object1",
|
|
|
|
"python34",
|
|
|
|
"struct_endian",
|
|
|
|
)
|
|
|
|
|
2020-11-29 23:28:48 +00:00
|
|
|
# Some tests shouldn't be run on GitHub Actions
|
|
|
|
if os.getenv("GITHUB_ACTIONS") == "true":
|
|
|
|
skip_tests.add("thread/stress_schedule.py") # has reliability issues
|
2014-05-03 16:43:27 +01:00
|
|
|
|
2017-06-26 04:47:00 +01:00
|
|
|
if upy_float_precision == 0:
|
2018-07-22 15:19:22 +01:00
|
|
|
skip_tests.add("extmod/uctypes_le_float.py")
|
|
|
|
skip_tests.add("extmod/uctypes_native_float.py")
|
|
|
|
skip_tests.add("extmod/uctypes_sizeof_float.py")
|
2017-06-26 04:47:00 +01:00
|
|
|
skip_tests.add("extmod/ujson_dumps_float.py")
|
|
|
|
skip_tests.add("extmod/ujson_loads_float.py")
|
2018-07-22 15:19:22 +01:00
|
|
|
skip_tests.add("extmod/urandom_extra_float.py")
|
2017-06-26 04:47:00 +01:00
|
|
|
skip_tests.add("misc/rge_sm.py")
|
|
|
|
if upy_float_precision < 32:
|
|
|
|
skip_tests.add(
|
|
|
|
"float/float2int_intbig.py"
|
|
|
|
) # requires fp32, there's float2int_fp30_intbig.py instead
|
|
|
|
skip_tests.add(
|
|
|
|
"float/string_format.py"
|
|
|
|
) # requires fp32, there's string_format_fp30.py instead
|
|
|
|
skip_tests.add("float/bytes_construct.py") # requires fp32
|
|
|
|
skip_tests.add("float/bytearray_construct.py") # requires fp32
|
|
|
|
if upy_float_precision < 64:
|
|
|
|
skip_tests.add("float/float_divmod.py") # tested by float/float_divmod_relaxed.py instead
|
|
|
|
skip_tests.add("float/float2int_doubleprec_intbig.py")
|
2022-07-12 14:48:38 +01:00
|
|
|
skip_tests.add("float/float_format_ints_doubleprec.py")
|
2017-11-27 01:51:52 +00:00
|
|
|
skip_tests.add("float/float_parse_doubleprec.py")
|
2017-06-26 04:47:00 +01:00
|
|
|
|
2015-12-06 12:56:37 +00:00
|
|
|
if not has_complex:
|
|
|
|
skip_tests.add("float/complex1.py")
|
2017-04-04 03:26:43 +01:00
|
|
|
skip_tests.add("float/complex1_intbig.py")
|
2023-02-09 04:19:32 +00:00
|
|
|
skip_tests.add("float/complex_reverse_op.py")
|
2020-08-29 05:04:59 +01:00
|
|
|
skip_tests.add("float/complex_special_methods.py")
|
2015-12-06 12:56:37 +00:00
|
|
|
skip_tests.add("float/int_big_float.py")
|
|
|
|
skip_tests.add("float/true_value.py")
|
|
|
|
skip_tests.add("float/types.py")
|
2022-07-04 08:35:46 +01:00
|
|
|
skip_tests.add("float/complex_dunder.py")
|
2015-12-06 12:56:37 +00:00
|
|
|
|
2016-12-22 00:26:06 +00:00
|
|
|
if not has_coverage:
|
|
|
|
skip_tests.add("cmdline/cmd_parsetree.py")
|
2021-07-26 15:43:35 +01:00
|
|
|
skip_tests.add("cmdline/repl_sys_ps1_ps2.py")
|
2022-12-15 18:15:18 +00:00
|
|
|
skip_tests.add("extmod/ussl_poll.py")
|
2016-12-22 00:26:06 +00:00
|
|
|
|
2016-07-09 16:52:57 +01:00
|
|
|
# Some tests shouldn't be run on a PC
|
2017-12-14 11:36:06 +00:00
|
|
|
if args.target == "unix":
|
2016-07-09 16:52:57 +01:00
|
|
|
# unix build does not have the GIL so can't run thread mutation tests
|
|
|
|
for t in tests:
|
|
|
|
if t.startswith("thread/mutate_"):
|
|
|
|
skip_tests.add(t)
|
|
|
|
|
2014-09-13 18:43:09 +01:00
|
|
|
# Some tests shouldn't be run on pyboard
|
2017-12-14 11:36:06 +00:00
|
|
|
if args.target != "unix":
|
2015-10-20 23:55:50 +01:00
|
|
|
skip_tests.add("basics/exception_chain.py") # warning is not printed
|
2015-04-04 22:05:30 +01:00
|
|
|
skip_tests.add("micropython/meminfo.py") # output is very different to PC output
|
2015-10-20 23:55:50 +01:00
|
|
|
skip_tests.add("extmod/machine_mem.py") # raw memory access not supported
|
2021-03-11 05:11:27 +00:00
|
|
|
|
2015-06-23 20:24:51 +01:00
|
|
|
if args.target == "wipy":
|
|
|
|
skip_tests.add("misc/print_exception.py") # requires error reporting full
|
2016-02-21 21:30:35 +00:00
|
|
|
skip_tests.update(
|
2021-03-11 05:11:27 +00:00
|
|
|
{
|
2016-02-21 21:30:35 +00:00
|
|
|
"extmod/uctypes_%s.py" % t
|
|
|
|
for t in "bytearray le native_le ptr_le ptr_native_le sizeof sizeof_native array_assign_le array_assign_native_le".split()
|
2021-03-11 05:11:27 +00:00
|
|
|
}
|
2016-02-21 21:30:35 +00:00
|
|
|
) # requires uctypes
|
2015-06-23 20:24:51 +01:00
|
|
|
skip_tests.add("extmod/zlibd_decompress.py") # requires zlib
|
2015-09-27 17:47:35 +01:00
|
|
|
skip_tests.add("extmod/uheapq1.py") # uheapq not supported by WiPy
|
2016-02-21 21:30:35 +00:00
|
|
|
skip_tests.add("extmod/urandom_basic.py") # requires urandom
|
|
|
|
skip_tests.add("extmod/urandom_extra.py") # requires urandom
|
2016-02-13 16:28:02 +00:00
|
|
|
elif args.target == "esp8266":
|
|
|
|
skip_tests.add("misc/rge_sm.py") # too large
|
2017-04-03 08:20:41 +01:00
|
|
|
elif args.target == "minimal":
|
2017-09-10 20:32:08 +01:00
|
|
|
skip_tests.add("basics/class_inplace_op.py") # all special methods not supported
|
2017-12-14 08:32:34 +00:00
|
|
|
skip_tests.add(
|
|
|
|
"basics/subclass_native_init.py"
|
|
|
|
) # native subclassing corner cases not support
|
2017-04-03 08:20:41 +01:00
|
|
|
skip_tests.add("misc/rge_sm.py") # too large
|
|
|
|
skip_tests.add("micropython/opt_level.py") # don't assume line numbers are stored
|
2018-07-19 23:50:00 +01:00
|
|
|
elif args.target == "nrf":
|
|
|
|
skip_tests.add("basics/memoryview1.py") # no item assignment for memoryview
|
|
|
|
skip_tests.add("extmod/urandom_basic.py") # unimplemented: urandom.seed
|
|
|
|
skip_tests.add("micropython/opt_level.py") # no support for line numbers
|
|
|
|
skip_tests.add("misc/non_compliant.py") # no item assignment for bytearray
|
|
|
|
for t in tests:
|
|
|
|
if t.startswith("basics/io_"):
|
|
|
|
skip_tests.add(t)
|
2022-04-28 14:22:24 +01:00
|
|
|
elif args.target == "renesas-ra":
|
|
|
|
skip_tests.add(
|
|
|
|
"extmod/utime_time_ns.py"
|
|
|
|
) # RA fsp rtc function doesn't support nano sec info
|
2019-08-19 01:59:27 +01:00
|
|
|
elif args.target == "qemu-arm":
|
|
|
|
skip_tests.add("misc/print_exception.py") # requires sys stdfiles
|
2015-06-23 20:24:51 +01:00
|
|
|
|
2014-09-17 22:56:34 +01:00
|
|
|
# Some tests are known to fail on 64-bit machines
|
|
|
|
if pyb is None and platform.architecture()[0] == "64bit":
|
2014-09-23 13:09:26 +01:00
|
|
|
pass
|
2014-09-17 22:56:34 +01:00
|
|
|
|
2014-10-04 07:39:15 +01:00
|
|
|
# Some tests use unsupported features on Windows
|
|
|
|
if os.name == "nt":
|
2015-08-06 11:31:37 +01:00
|
|
|
skip_tests.add("import/import_file.py") # works but CPython prints forward slashes
|
2014-10-04 07:39:15 +01:00
|
|
|
|
2014-08-29 19:47:10 +01:00
|
|
|
# Some tests are known to fail with native emitter
|
|
|
|
# Remove them from the below when they work
|
|
|
|
if args.emit == "native":
|
2018-10-01 04:10:38 +01:00
|
|
|
skip_tests.update(
|
|
|
|
{"basics/%s.py" % t for t in "gen_yield_from_close generator_name".split()}
|
|
|
|
) # require raise_varargs, generator name
|
|
|
|
skip_tests.update(
|
|
|
|
{"basics/async_%s.py" % t for t in "with with2 with_break with_return".split()}
|
|
|
|
) # require async_with
|
2015-04-06 22:38:53 +01:00
|
|
|
skip_tests.update(
|
|
|
|
{"basics/%s.py" % t for t in "try_reraise try_reraise2".split()}
|
|
|
|
) # require raise_varargs
|
2020-06-16 13:49:38 +01:00
|
|
|
skip_tests.add("basics/annotate_var.py") # requires checking for unbound local
|
2015-04-06 22:38:53 +01:00
|
|
|
skip_tests.add("basics/del_deref.py") # requires checking for unbound local
|
|
|
|
skip_tests.add("basics/del_local.py") # requires checking for unbound local
|
2015-09-01 09:53:27 +01:00
|
|
|
skip_tests.add("basics/exception_chain.py") # raise from is not supported
|
2022-06-24 15:05:39 +01:00
|
|
|
skip_tests.add("basics/fun_name.py") # requires proper names for native functions
|
2018-10-26 06:48:07 +01:00
|
|
|
skip_tests.add("basics/scope_implicit.py") # requires checking for unbound local
|
2021-07-26 15:41:27 +01:00
|
|
|
skip_tests.add("basics/sys_tracebacklimit.py") # requires traceback info
|
2018-09-04 05:33:43 +01:00
|
|
|
skip_tests.add("basics/try_finally_return2.py") # requires raise_varargs
|
2015-04-06 22:38:53 +01:00
|
|
|
skip_tests.add("basics/unboundlocal.py") # requires checking for unbound local
|
2020-12-01 03:22:16 +00:00
|
|
|
skip_tests.add("extmod/uasyncio_event.py") # unknown issue
|
2020-01-23 06:57:46 +00:00
|
|
|
skip_tests.add("extmod/uasyncio_lock.py") # requires async with
|
2020-12-01 03:22:16 +00:00
|
|
|
skip_tests.add("extmod/uasyncio_micropython.py") # unknown issue
|
|
|
|
skip_tests.add("extmod/uasyncio_wait_for.py") # unknown issue
|
2015-04-06 22:38:53 +01:00
|
|
|
skip_tests.add("misc/features.py") # requires raise_varargs
|
2014-12-11 17:34:55 +00:00
|
|
|
skip_tests.add(
|
|
|
|
"misc/print_exception.py"
|
|
|
|
) # because native doesn't have proper traceback info
|
2015-04-25 01:17:41 +01:00
|
|
|
skip_tests.add("misc/sys_exc_info.py") # sys.exc_info() is not supported for native
|
2022-05-15 23:48:18 +01:00
|
|
|
skip_tests.add("misc/sys_settrace_features.py") # sys.settrace() not supported
|
|
|
|
skip_tests.add("misc/sys_settrace_generator.py") # sys.settrace() not supported
|
|
|
|
skip_tests.add("misc/sys_settrace_loop.py") # sys.settrace() not supported
|
2017-09-21 06:24:57 +01:00
|
|
|
skip_tests.add(
|
|
|
|
"micropython/emg_exc.py"
|
|
|
|
) # because native doesn't have proper traceback info
|
2016-11-21 06:39:23 +00:00
|
|
|
skip_tests.add(
|
|
|
|
"micropython/heapalloc_traceback.py"
|
|
|
|
) # because native doesn't have proper traceback info
|
2019-08-23 02:25:46 +01:00
|
|
|
skip_tests.add(
|
|
|
|
"micropython/opt_level_lineno.py"
|
|
|
|
) # native doesn't have proper traceback info
|
2017-03-16 07:05:00 +00:00
|
|
|
skip_tests.add("micropython/schedule.py") # native code doesn't check pending events
|
2022-03-15 22:37:58 +00:00
|
|
|
skip_tests.add("stress/bytecode_limit.py") # bytecode specific test
|
2014-08-29 19:47:10 +01:00
|
|
|
|
2021-05-11 14:24:36 +01:00
|
|
|
def run_one_test(test_file):
|
2015-08-06 11:31:37 +01:00
|
|
|
test_file = test_file.replace("\\", "/")
|
2017-12-14 10:26:10 +00:00
|
|
|
|
|
|
|
if args.filters:
|
|
|
|
# Default verdict is the opposit of the first action
|
|
|
|
verdict = "include" if args.filters[0][0] == "exclude" else "exclude"
|
|
|
|
for action, pat in args.filters:
|
|
|
|
if pat.search(test_file):
|
|
|
|
verdict = action
|
|
|
|
if verdict == "exclude":
|
2021-05-11 14:24:36 +01:00
|
|
|
return
|
2017-12-14 10:26:10 +00:00
|
|
|
|
2018-08-08 14:20:22 +01:00
|
|
|
test_basename = test_file.replace("..", "_").replace("./", "").replace("/", "_")
|
|
|
|
test_name = os.path.splitext(os.path.basename(test_file))[0]
|
2020-03-11 09:01:46 +00:00
|
|
|
is_native = (
|
|
|
|
test_name.startswith("native_")
|
|
|
|
or test_name.startswith("viper_")
|
|
|
|
or args.emit == "native"
|
2021-03-11 05:11:27 +00:00
|
|
|
)
|
2015-08-29 22:28:59 +01:00
|
|
|
is_endian = test_name.endswith("_endian")
|
2017-03-03 21:13:27 +00:00
|
|
|
is_int_big = test_name.startswith("int_big") or test_name.endswith("_intbig")
|
2019-10-18 09:48:15 +01:00
|
|
|
is_bytearray = test_name.startswith("bytearray") or test_name.endswith("_bytearray")
|
2022-03-07 05:45:40 +00:00
|
|
|
is_set_type = test_name.startswith(("set_", "frozenset")) or test_name.endswith("_set")
|
2019-10-29 11:01:17 +00:00
|
|
|
is_slice = test_name.find("slice") != -1 or test_name in misc_slice_tests
|
2020-01-23 06:57:46 +00:00
|
|
|
is_async = test_name.startswith(("async_", "uasyncio_"))
|
2017-04-02 20:51:31 +01:00
|
|
|
is_const = test_name.startswith("const")
|
2019-10-29 11:13:38 +00:00
|
|
|
is_io_module = test_name.startswith("io_")
|
2021-08-12 16:44:08 +01:00
|
|
|
is_fstring = test_name.startswith("string_fstring")
|
2017-01-04 21:16:29 +00:00
|
|
|
|
|
|
|
skip_it = test_file in skip_tests
|
|
|
|
skip_it |= skip_native and is_native
|
|
|
|
skip_it |= skip_endian and is_endian
|
2017-03-03 17:14:02 +00:00
|
|
|
skip_it |= skip_int_big and is_int_big
|
2019-10-18 09:48:15 +01:00
|
|
|
skip_it |= skip_bytearray and is_bytearray
|
2017-01-04 21:16:29 +00:00
|
|
|
skip_it |= skip_set_type and is_set_type
|
2019-10-29 10:44:22 +00:00
|
|
|
skip_it |= skip_slice and is_slice
|
2017-02-14 19:03:25 +00:00
|
|
|
skip_it |= skip_async and is_async
|
2017-04-02 20:51:31 +01:00
|
|
|
skip_it |= skip_const and is_const
|
2020-08-29 05:04:59 +01:00
|
|
|
skip_it |= skip_revops and "reverse_op" in test_name
|
2019-10-29 11:13:38 +00:00
|
|
|
skip_it |= skip_io_module and is_io_module
|
2021-08-12 16:44:08 +01:00
|
|
|
skip_it |= skip_fstring and is_fstring
|
2014-06-05 22:41:30 +01:00
|
|
|
|
2017-12-14 10:11:17 +00:00
|
|
|
if args.list_tests:
|
|
|
|
if not skip_it:
|
|
|
|
print(test_file)
|
2021-05-11 14:24:36 +01:00
|
|
|
return
|
2017-12-14 10:11:17 +00:00
|
|
|
|
2017-01-04 21:16:29 +00:00
|
|
|
if skip_it:
|
2014-05-03 16:43:27 +01:00
|
|
|
print("skip ", test_file)
|
2014-05-10 14:52:58 +01:00
|
|
|
skipped_tests.append(test_name)
|
2021-05-11 14:24:36 +01:00
|
|
|
return
|
2014-05-03 16:43:27 +01:00
|
|
|
|
|
|
|
# get expected output
|
|
|
|
test_file_expected = test_file + ".exp"
|
|
|
|
if os.path.isfile(test_file_expected):
|
|
|
|
# expected output given by a file, so read that in
|
|
|
|
with open(test_file_expected, "rb") as f:
|
|
|
|
output_expected = f.read()
|
|
|
|
else:
|
2014-05-11 11:45:02 +01:00
|
|
|
# run CPython to work out expected output
|
2014-05-03 16:43:27 +01:00
|
|
|
try:
|
2020-09-24 03:03:30 +01:00
|
|
|
output_expected = subprocess.check_output(CPYTHON3_CMD + [test_file])
|
2014-07-12 14:34:51 +01:00
|
|
|
if args.write_exp:
|
|
|
|
with open(test_file_expected, "wb") as f:
|
|
|
|
f.write(output_expected)
|
2014-05-03 16:43:27 +01:00
|
|
|
except subprocess.CalledProcessError:
|
|
|
|
output_expected = b"CPYTHON3 CRASH"
|
|
|
|
|
2016-03-07 12:01:21 +00:00
|
|
|
# canonical form for all host platforms is to use \n for end-of-line
|
|
|
|
output_expected = output_expected.replace(b"\r\n", b"\n")
|
|
|
|
|
2014-07-12 14:34:51 +01:00
|
|
|
if args.write_exp:
|
2021-05-11 14:24:36 +01:00
|
|
|
return
|
2014-07-12 14:34:51 +01:00
|
|
|
|
2017-06-30 08:22:17 +01:00
|
|
|
# run MicroPython
|
2014-10-05 22:27:12 +01:00
|
|
|
output_mupy = run_micropython(pyb, args, test_file)
|
2014-05-03 16:43:27 +01:00
|
|
|
|
2016-03-07 12:01:21 +00:00
|
|
|
if output_mupy == b"SKIP\n":
|
2014-05-10 14:52:58 +01:00
|
|
|
print("skip ", test_file)
|
|
|
|
skipped_tests.append(test_name)
|
2021-05-11 14:24:36 +01:00
|
|
|
return
|
2014-05-10 14:52:58 +01:00
|
|
|
|
2021-05-11 14:24:36 +01:00
|
|
|
testcase_count.add(len(output_expected.splitlines()))
|
2014-05-10 14:52:58 +01:00
|
|
|
|
2020-04-07 15:19:49 +01:00
|
|
|
filename_expected = os.path.join(result_dir, test_basename + ".exp")
|
|
|
|
filename_mupy = os.path.join(result_dir, test_basename + ".out")
|
2014-05-03 16:43:27 +01:00
|
|
|
|
|
|
|
if output_expected == output_mupy:
|
|
|
|
print("pass ", test_file)
|
2021-05-11 14:24:36 +01:00
|
|
|
passed_count.increment()
|
2014-05-03 16:43:27 +01:00
|
|
|
rm_f(filename_expected)
|
|
|
|
rm_f(filename_mupy)
|
|
|
|
else:
|
2014-06-28 10:29:12 +01:00
|
|
|
with open(filename_expected, "wb") as f:
|
|
|
|
f.write(output_expected)
|
|
|
|
with open(filename_mupy, "wb") as f:
|
|
|
|
f.write(output_mupy)
|
2014-05-03 16:43:27 +01:00
|
|
|
print("FAIL ", test_file)
|
|
|
|
failed_tests.append(test_name)
|
|
|
|
|
2021-05-11 14:24:36 +01:00
|
|
|
test_count.increment()
|
|
|
|
|
|
|
|
if pyb or args.list_tests:
|
|
|
|
num_threads = 1
|
|
|
|
|
|
|
|
if num_threads > 1:
|
|
|
|
pool = ThreadPool(num_threads)
|
|
|
|
pool.map(run_one_test, tests)
|
|
|
|
else:
|
|
|
|
for test in tests:
|
|
|
|
run_one_test(test)
|
2014-05-03 16:43:27 +01:00
|
|
|
|
2017-12-13 16:01:35 +00:00
|
|
|
if args.list_tests:
|
|
|
|
return True
|
|
|
|
|
2021-05-11 14:24:36 +01:00
|
|
|
print(
|
|
|
|
"{} tests performed ({} individual testcases)".format(
|
|
|
|
test_count.value, testcase_count.value
|
|
|
|
)
|
|
|
|
)
|
|
|
|
print("{} tests passed".format(passed_count.value))
|
2014-05-03 16:43:27 +01:00
|
|
|
|
2021-05-11 14:24:36 +01:00
|
|
|
skipped_tests = sorted(skipped_tests.value)
|
2014-05-10 14:52:58 +01:00
|
|
|
if len(skipped_tests) > 0:
|
|
|
|
print("{} tests skipped: {}".format(len(skipped_tests), " ".join(skipped_tests)))
|
2021-05-11 14:24:36 +01:00
|
|
|
failed_tests = sorted(failed_tests.value)
|
2014-05-03 16:43:27 +01:00
|
|
|
if len(failed_tests) > 0:
|
|
|
|
print("{} tests failed: {}".format(len(failed_tests), " ".join(failed_tests)))
|
|
|
|
return False
|
|
|
|
|
|
|
|
# all tests succeeded
|
|
|
|
return True
|
|
|
|
|
2017-12-14 10:26:10 +00:00
|
|
|
|
|
|
|
class append_filter(argparse.Action):
|
|
|
|
def __init__(self, option_strings, dest, **kwargs):
|
|
|
|
super().__init__(option_strings, dest, default=[], **kwargs)
|
|
|
|
|
|
|
|
def __call__(self, parser, args, value, option):
|
|
|
|
if not hasattr(args, self.dest):
|
|
|
|
args.filters = []
|
|
|
|
if option.startswith(("-e", "--e")):
|
|
|
|
option = "exclude"
|
|
|
|
else:
|
|
|
|
option = "include"
|
|
|
|
args.filters.append((option, re.compile(value)))
|
|
|
|
|
|
|
|
|
2014-05-03 16:43:27 +01:00
|
|
|
def main():
|
2017-12-14 10:26:10 +00:00
|
|
|
cmd_parser = argparse.ArgumentParser(
|
|
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
2020-01-16 17:07:50 +00:00
|
|
|
description="""Run and manage tests for MicroPython.
|
|
|
|
|
2020-04-08 07:01:58 +01:00
|
|
|
Tests are discovered by scanning test directories for .py files or using the
|
|
|
|
specified test files. If test files nor directories are specified, the script
|
|
|
|
expects to be ran in the tests directory (where this file is located) and the
|
|
|
|
builtin tests suitable for the target platform are ran.
|
2021-03-11 05:09:27 +00:00
|
|
|
When running tests, run-tests.py compares the MicroPython output of the test with the output
|
2020-01-16 17:07:50 +00:00
|
|
|
produced by running the test through CPython unless a <test>.exp file is found, in which
|
|
|
|
case it is used as comparison.
|
2021-03-11 05:09:27 +00:00
|
|
|
If a test fails, run-tests.py produces a pair of <test>.out and <test>.exp files in the result
|
2020-01-16 17:07:50 +00:00
|
|
|
directory with the MicroPython output and the expectations, respectively.
|
|
|
|
""",
|
2017-12-14 10:26:10 +00:00
|
|
|
epilog="""\
|
|
|
|
Options -i and -e can be multiple and processed in the order given. Regex
|
|
|
|
"search" (vs "match") operation is used. An action (include/exclude) of
|
|
|
|
the last matching regex is used:
|
2021-03-11 05:09:27 +00:00
|
|
|
run-tests.py -i async - exclude all, then include tests containing "async" anywhere
|
|
|
|
run-tests.py -e '/big.+int' - include all, then exclude by regex
|
|
|
|
run-tests.py -e async -i async_foo - include all, exclude async, yet still include async_foo
|
2021-03-11 05:11:27 +00:00
|
|
|
""",
|
2017-12-14 10:26:10 +00:00
|
|
|
)
|
2015-06-23 20:24:51 +01:00
|
|
|
cmd_parser.add_argument("--target", default="unix", help="the target platform")
|
2015-06-28 13:01:27 +01:00
|
|
|
cmd_parser.add_argument(
|
|
|
|
"--device",
|
|
|
|
default="/dev/ttyACM0",
|
|
|
|
help="the serial device or the IP address of the pyboard",
|
|
|
|
)
|
|
|
|
cmd_parser.add_argument(
|
|
|
|
"-b", "--baudrate", default=115200, help="the baud rate of the serial device"
|
|
|
|
)
|
|
|
|
cmd_parser.add_argument("-u", "--user", default="micro", help="the telnet login username")
|
|
|
|
cmd_parser.add_argument("-p", "--password", default="python", help="the telnet login password")
|
2014-05-31 18:11:01 +01:00
|
|
|
cmd_parser.add_argument(
|
|
|
|
"-d", "--test-dirs", nargs="*", help="input test directories (if no files given)"
|
|
|
|
)
|
2020-04-07 15:19:49 +01:00
|
|
|
cmd_parser.add_argument(
|
|
|
|
"-r", "--result-dir", default=base_path("results"), help="directory for test results"
|
|
|
|
)
|
2017-12-14 10:26:10 +00:00
|
|
|
cmd_parser.add_argument(
|
|
|
|
"-e",
|
|
|
|
"--exclude",
|
|
|
|
action=append_filter,
|
|
|
|
metavar="REGEX",
|
|
|
|
dest="filters",
|
|
|
|
help="exclude test by regex on path/name.py",
|
|
|
|
)
|
|
|
|
cmd_parser.add_argument(
|
|
|
|
"-i",
|
|
|
|
"--include",
|
|
|
|
action=append_filter,
|
|
|
|
metavar="REGEX",
|
|
|
|
dest="filters",
|
|
|
|
help="include test by regex on path/name.py",
|
2020-01-16 17:07:50 +00:00
|
|
|
)
|
|
|
|
cmd_parser.add_argument(
|
|
|
|
"--write-exp",
|
|
|
|
action="store_true",
|
|
|
|
help="use CPython to generate .exp files to run tests w/o CPython",
|
2017-12-13 16:01:35 +00:00
|
|
|
)
|
|
|
|
cmd_parser.add_argument(
|
|
|
|
"--list-tests", action="store_true", help="list tests instead of running them"
|
2015-10-12 00:06:25 +01:00
|
|
|
)
|
|
|
|
cmd_parser.add_argument(
|
|
|
|
"--emit", default="bytecode", help="MicroPython emitter to use (bytecode or native)"
|
2021-03-11 05:11:27 +00:00
|
|
|
)
|
2016-03-15 13:04:43 +00:00
|
|
|
cmd_parser.add_argument("--heapsize", help="heapsize to use (use default if not specified)")
|
2016-09-20 03:19:35 +01:00
|
|
|
cmd_parser.add_argument(
|
|
|
|
"--via-mpy", action="store_true", help="compile .py files to .mpy first"
|
|
|
|
)
|
all: Remove MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE.
This commit removes all parts of code associated with the existing
MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE optimisation option, including the
-mcache-lookup-bc option to mpy-cross.
This feature originally provided a significant performance boost for Unix,
but wasn't able to be enabled for MCU targets (due to frozen bytecode), and
added significant extra complexity to generating and distributing .mpy
files.
The equivalent performance gain is now provided by the combination of
MICROPY_OPT_LOAD_ATTR_FAST_PATH and MICROPY_OPT_MAP_LOOKUP_CACHE (which has
been enabled on the unix port in the previous commit).
It's hard to provide precise performance numbers, but tests have been run
on a wide variety of architectures (x86-64, ARM Cortex, Aarch64, RISC-V,
xtensa) and they all generally agree on the qualitative improvements seen
by the combination of MICROPY_OPT_LOAD_ATTR_FAST_PATH and
MICROPY_OPT_MAP_LOOKUP_CACHE.
For example, on a "quiet" Linux x64 environment (i3-5010U @ 2.10GHz) the
change from CACHE_MAP_LOOKUP_IN_BYTECODE, to LOAD_ATTR_FAST_PATH combined
with MAP_LOOKUP_CACHE is:
diff of scores (higher is better)
N=2000 M=2000 bccache -> attrmapcache diff diff% (error%)
bm_chaos.py 13742.56 -> 13905.67 : +163.11 = +1.187% (+/-3.75%)
bm_fannkuch.py 60.13 -> 61.34 : +1.21 = +2.012% (+/-2.11%)
bm_fft.py 113083.20 -> 114793.68 : +1710.48 = +1.513% (+/-1.57%)
bm_float.py 256552.80 -> 243908.29 : -12644.51 = -4.929% (+/-1.90%)
bm_hexiom.py 521.93 -> 625.41 : +103.48 = +19.826% (+/-0.40%)
bm_nqueens.py 197544.25 -> 217713.12 : +20168.87 = +10.210% (+/-3.01%)
bm_pidigits.py 8072.98 -> 8198.75 : +125.77 = +1.558% (+/-3.22%)
misc_aes.py 17283.45 -> 16480.52 : -802.93 = -4.646% (+/-0.82%)
misc_mandel.py 99083.99 -> 128939.84 : +29855.85 = +30.132% (+/-5.88%)
misc_pystone.py 83860.10 -> 82592.56 : -1267.54 = -1.511% (+/-2.27%)
misc_raytrace.py 21490.40 -> 22227.23 : +736.83 = +3.429% (+/-1.88%)
This shows that the new optimisations are at least as good as the existing
inline-bytecode-caching, and are sometimes much better (because the new
ones apply caching to a wider variety of map lookups).
The new optimisations can also benefit code generated by the native
emitter, because they apply to the runtime rather than the generated code.
The improvement for the native emitter when LOAD_ATTR_FAST_PATH and
MAP_LOOKUP_CACHE are enabled is (same Linux environment as above):
diff of scores (higher is better)
N=2000 M=2000 native -> nat-attrmapcache diff diff% (error%)
bm_chaos.py 14130.62 -> 15464.68 : +1334.06 = +9.441% (+/-7.11%)
bm_fannkuch.py 74.96 -> 76.16 : +1.20 = +1.601% (+/-1.80%)
bm_fft.py 166682.99 -> 168221.86 : +1538.87 = +0.923% (+/-4.20%)
bm_float.py 233415.23 -> 265524.90 : +32109.67 = +13.756% (+/-2.57%)
bm_hexiom.py 628.59 -> 734.17 : +105.58 = +16.796% (+/-1.39%)
bm_nqueens.py 225418.44 -> 232926.45 : +7508.01 = +3.331% (+/-3.10%)
bm_pidigits.py 6322.00 -> 6379.52 : +57.52 = +0.910% (+/-5.62%)
misc_aes.py 20670.10 -> 27223.18 : +6553.08 = +31.703% (+/-1.56%)
misc_mandel.py 138221.11 -> 152014.01 : +13792.90 = +9.979% (+/-2.46%)
misc_pystone.py 85032.14 -> 105681.44 : +20649.30 = +24.284% (+/-2.25%)
misc_raytrace.py 19800.01 -> 23350.73 : +3550.72 = +17.933% (+/-2.79%)
In summary, compared to MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE, the new
MICROPY_OPT_LOAD_ATTR_FAST_PATH and MICROPY_OPT_MAP_LOOKUP_CACHE options:
- are simpler;
- take less code size;
- are faster (generally);
- work with code generated by the native emitter;
- can be used on embedded targets with a small and constant RAM overhead;
- allow the same .mpy bytecode to run on all targets.
See #7680 for further discussion. And see also #7653 for a discussion
about simplifying mpy-cross options.
Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
2021-09-06 03:28:06 +01:00
|
|
|
cmd_parser.add_argument("--mpy-cross-flags", default="", help="flags to pass to mpy-cross")
|
2015-03-24 10:55:26 +00:00
|
|
|
cmd_parser.add_argument(
|
|
|
|
"--keep-path", action="store_true", help="do not clear MICROPYPATH when running tests"
|
|
|
|
)
|
2021-05-11 14:24:36 +01:00
|
|
|
cmd_parser.add_argument(
|
|
|
|
"-j",
|
|
|
|
"--jobs",
|
|
|
|
default=multiprocessing.cpu_count(),
|
|
|
|
metavar="N",
|
|
|
|
type=int,
|
|
|
|
help="Number of tests to run simultaneously",
|
|
|
|
)
|
2014-05-03 16:43:27 +01:00
|
|
|
cmd_parser.add_argument("files", nargs="*", help="input test files")
|
2020-03-27 03:41:38 +00:00
|
|
|
cmd_parser.add_argument(
|
|
|
|
"--print-failures",
|
|
|
|
action="store_true",
|
|
|
|
help="print the diff of expected vs. actual output for failed tests and exit",
|
|
|
|
)
|
|
|
|
cmd_parser.add_argument(
|
|
|
|
"--clean-failures",
|
|
|
|
action="store_true",
|
|
|
|
help="delete the .exp and .out files from failed tests and exit",
|
|
|
|
)
|
2014-05-03 16:43:27 +01:00
|
|
|
args = cmd_parser.parse_args()
|
|
|
|
|
2020-03-27 03:41:38 +00:00
|
|
|
if args.print_failures:
|
2020-04-07 15:19:49 +01:00
|
|
|
for exp in glob(os.path.join(args.result_dir, "*.exp")):
|
2020-04-08 07:01:58 +01:00
|
|
|
testbase = exp[:-4]
|
2020-03-27 03:41:38 +00:00
|
|
|
print()
|
|
|
|
print("FAILURE {0}".format(testbase))
|
2020-03-30 09:14:09 +01:00
|
|
|
os.system("{0} {1}.exp {1}.out".format(DIFF, testbase))
|
2020-03-27 03:41:38 +00:00
|
|
|
|
|
|
|
sys.exit(0)
|
|
|
|
|
|
|
|
if args.clean_failures:
|
2020-04-07 15:19:49 +01:00
|
|
|
for f in glob(os.path.join(args.result_dir, "*.exp")) + glob(
|
|
|
|
os.path.join(args.result_dir, "*.out")
|
|
|
|
):
|
2020-03-27 03:41:38 +00:00
|
|
|
os.remove(f)
|
|
|
|
|
|
|
|
sys.exit(0)
|
|
|
|
|
2019-08-19 01:59:27 +01:00
|
|
|
LOCAL_TARGETS = (
|
|
|
|
"unix",
|
|
|
|
"qemu-arm",
|
|
|
|
)
|
2022-05-26 03:27:04 +01:00
|
|
|
EXTERNAL_TARGETS = (
|
|
|
|
"pyboard",
|
|
|
|
"wipy",
|
|
|
|
"esp8266",
|
|
|
|
"esp32",
|
|
|
|
"minimal",
|
|
|
|
"nrf",
|
|
|
|
"renesas-ra",
|
|
|
|
"rp2",
|
|
|
|
)
|
2022-11-17 11:49:36 +00:00
|
|
|
if args.list_tests:
|
|
|
|
pyb = None
|
|
|
|
elif args.target in LOCAL_TARGETS:
|
2017-12-13 16:01:35 +00:00
|
|
|
pyb = None
|
2022-11-17 11:49:36 +00:00
|
|
|
if not args.mpy_cross_flags:
|
|
|
|
if args.target == "unix":
|
|
|
|
args.mpy_cross_flags = "-march=host"
|
|
|
|
elif args.target == "qemu-arm":
|
|
|
|
args.mpy_cross_flags = "-march=armv7m"
|
2017-12-13 16:01:35 +00:00
|
|
|
elif args.target in EXTERNAL_TARGETS:
|
2018-09-05 06:35:18 +01:00
|
|
|
global pyboard
|
2020-04-08 07:01:58 +01:00
|
|
|
sys.path.append(base_path("../tools"))
|
2014-05-03 16:43:27 +01:00
|
|
|
import pyboard
|
2021-03-11 05:11:27 +00:00
|
|
|
|
2022-05-19 05:54:06 +01:00
|
|
|
if not args.mpy_cross_flags:
|
|
|
|
if args.target == "esp8266":
|
|
|
|
args.mpy_cross_flags = "-march=xtensa"
|
|
|
|
elif args.target == "esp32":
|
|
|
|
args.mpy_cross_flags = "-march=xtensawin"
|
2022-05-26 03:27:04 +01:00
|
|
|
elif args.target == "rp2":
|
|
|
|
args.mpy_cross_flags = "-march=armv6m"
|
|
|
|
elif args.target == "pyboard":
|
|
|
|
args.mpy_cross_flags = "-march=armv7emsp"
|
2022-05-19 05:54:06 +01:00
|
|
|
else:
|
|
|
|
args.mpy_cross_flags = "-march=armv7m"
|
|
|
|
|
2015-06-28 13:01:27 +01:00
|
|
|
pyb = pyboard.Pyboard(args.device, args.baudrate, args.user, args.password)
|
2014-04-13 13:48:33 +01:00
|
|
|
pyb.enter_raw_repl()
|
2015-06-23 20:24:51 +01:00
|
|
|
else:
|
2019-08-19 01:59:27 +01:00
|
|
|
raise ValueError("target must be one of %s" % ", ".join(LOCAL_TARGETS + EXTERNAL_TARGETS))
|
2014-05-03 16:43:27 +01:00
|
|
|
|
|
|
|
if len(args.files) == 0:
|
2014-05-28 13:27:54 +01:00
|
|
|
if args.test_dirs is None:
|
2019-08-19 01:59:27 +01:00
|
|
|
test_dirs = (
|
|
|
|
"basics",
|
|
|
|
"micropython",
|
|
|
|
"misc",
|
|
|
|
"extmod",
|
|
|
|
)
|
2015-06-23 20:24:51 +01:00
|
|
|
if args.target == "pyboard":
|
2014-05-28 13:27:54 +01:00
|
|
|
# run pyboard tests
|
2022-05-26 03:31:31 +01:00
|
|
|
test_dirs += ("float", "stress", "pyb", "inlineasm")
|
2022-04-28 14:22:24 +01:00
|
|
|
elif args.target in ("renesas-ra"):
|
|
|
|
test_dirs += ("float", "inlineasm", "renesas-ra")
|
2022-05-26 03:27:04 +01:00
|
|
|
elif args.target == "rp2":
|
|
|
|
test_dirs += ("float", "stress", "inlineasm")
|
2018-07-19 23:50:00 +01:00
|
|
|
elif args.target in ("esp8266", "esp32", "minimal", "nrf"):
|
2019-08-19 01:59:27 +01:00
|
|
|
test_dirs += ("float",)
|
2015-06-23 20:24:51 +01:00
|
|
|
elif args.target == "wipy":
|
|
|
|
# run WiPy tests
|
2019-08-19 01:59:27 +01:00
|
|
|
test_dirs += ("wipy",)
|
|
|
|
elif args.target == "unix":
|
2015-06-23 20:24:51 +01:00
|
|
|
# run PC tests
|
2019-08-19 01:59:27 +01:00
|
|
|
test_dirs += (
|
|
|
|
"float",
|
|
|
|
"import",
|
|
|
|
"io",
|
|
|
|
"stress",
|
|
|
|
"unicode",
|
|
|
|
"unix",
|
|
|
|
"cmdline",
|
|
|
|
)
|
|
|
|
elif args.target == "qemu-arm":
|
|
|
|
if not args.write_exp:
|
|
|
|
raise ValueError("--target=qemu-arm must be used with --write-exp")
|
|
|
|
# Generate expected output files for qemu run.
|
|
|
|
# This list should match the test_dirs tuple in tinytest-codegen.py.
|
|
|
|
test_dirs += (
|
|
|
|
"float",
|
|
|
|
"inlineasm",
|
|
|
|
"qemu-arm",
|
|
|
|
)
|
2014-05-03 16:43:27 +01:00
|
|
|
else:
|
2014-05-28 13:27:54 +01:00
|
|
|
# run tests from these directories
|
|
|
|
test_dirs = args.test_dirs
|
2014-05-03 16:43:27 +01:00
|
|
|
tests = sorted(
|
|
|
|
test_file
|
|
|
|
for test_files in (glob("{}/*.py".format(dir)) for dir in test_dirs)
|
|
|
|
for test_file in test_files
|
|
|
|
)
|
2014-01-27 21:53:28 +00:00
|
|
|
else:
|
2014-05-03 16:43:27 +01:00
|
|
|
# tests explicitly given
|
|
|
|
tests = args.files
|
2014-01-27 21:53:28 +00:00
|
|
|
|
2015-03-24 10:55:26 +00:00
|
|
|
if not args.keep_path:
|
2020-03-09 15:58:47 +00:00
|
|
|
# clear search path to make sure tests use only builtin modules and those in extmod
|
2021-12-21 12:07:00 +00:00
|
|
|
os.environ["MICROPYPATH"] = ".frozen" + os.pathsep + base_path("../extmod")
|
2015-03-24 10:55:26 +00:00
|
|
|
|
2017-10-07 13:49:58 +01:00
|
|
|
try:
|
2020-04-07 15:19:49 +01:00
|
|
|
os.makedirs(args.result_dir, exist_ok=True)
|
2021-05-11 14:24:36 +01:00
|
|
|
res = run_tests(pyb, tests, args, args.result_dir, args.jobs)
|
2017-10-07 13:49:58 +01:00
|
|
|
finally:
|
|
|
|
if pyb:
|
|
|
|
pyb.close()
|
|
|
|
|
2017-04-02 18:47:44 +01:00
|
|
|
if not res:
|
2014-05-03 16:43:27 +01:00
|
|
|
sys.exit(1)
|
2014-01-27 21:53:28 +00:00
|
|
|
|
2021-03-11 05:11:27 +00:00
|
|
|
|
2014-05-03 16:43:27 +01:00
|
|
|
if __name__ == "__main__":
|
|
|
|
main()
|