env = os.environ.get(name)

if env is None:

return default

'--experimental-options',

'--python.PosixModuleBackend=java',

'--python.Sha3ModuleBackend=java',

for result in original_DefaultNativeProject_getArchivableResults(self, *args, **kwargs):

if any(r.endswith("pythonjni.dll") for r in result):

yield tuple(r.replace(".dll", ".lib") for r in result)

non_internal = []

additional_dists = []

for arg in args:

# Class path extensions

if arg.startswith('-add-dist='):

additional_dists += [arg[10:]]

else:

non_internal += [arg]

if register_project and register_distribution:

isolate_build_options = [

'-H:+DetectUserDirectoriesInImageHeap',

]

meta_pom = None

for dist in SUITE.dists:

if dist.name == 'PYTHON_POM':

meta_pom = dist

assert meta_pom, "Cannot find python meta-POM distribution in the graalpython suite"

mx_truffle.register_polyglot_isolate_distributions(SUITE, register_project, register_distribution, 'python',

'graalpython', meta_pom.name, meta_pom.maven_group_id(), meta_pom.theLicense,

if not SUITE_COMPILER:

if must_be_jvmci:

mx.abort('** Error ** : graal compiler was not found!')

sys.exit(1)

if vm_warning:

build_args = []

build_args += bytecode_dsl_build_args()

if mx_sdk_vm_ng.is_nativeimage_ee() and mx.get_os() == 'linux' and 'NATIVE_IMAGE_AUXILIARY_ENGINE_CACHE' not in os.environ:

build_args += ['--gc=G1', '-H:-ProtectionKeys']

"""Run python from standalone build (unless kwargs are given). Does not build GraalPython sources automatically."""

if not any(arg.startswith('--python.WithJavaStacktrace') for arg in args):

args.insert(0, '--python.WithJavaStacktrace=1')

if "--hosted" in args[:2]:

args.remove("--hosted")

return python(args)

if '--vm.da' not in args:

args.insert(0, '--vm.ea')

if not any(arg.startswith('--experimental-options') for arg in args):

args.insert(0, '--experimental-options')

handle_debug_arg(args)

for arg in itertools.chain(

itertools.chain(*map(shlex.split, reversed(mx._opts.java_args_sfx))),

reversed(shlex.split(mx._opts.java_args if mx._opts.java_args else "")),

itertools.chain(*map(shlex.split, reversed(mx._opts.java_args_pfx))),

):

if arg.startswith("-"):

args.insert(0, f"--vm.{arg[1:]}")

else:

mx.warn(f"Dropping {arg}, cannot pass it to launcher")

standalone_home = graalpy_standalone_home('jvm', dev=True, build=False)

graalpy_path = os.path.join(standalone_home, 'bin', _graalpy_launcher())

if not os.path.exists(graalpy_path):

mx.abort("GraalPy standalone doesn't seem to be built.\n" +

"To build it: mx python-jvm\n" +

"Alternatively use: mx python --hosted")

"""run a Python program or shell"""

if not any(arg.startswith('--python.WithJavaStacktrace') for arg in args):

args.insert(0, '--python.WithJavaStacktrace=1')

if not any(arg.startswith("--python.CAPI") for arg in args):

capi_home = _get_capi_home()

args.insert(0, "--python.CAPI=%s" % capi_home)

args.insert(0, "--experimental-options")

if not env:

env = os.environ.copy()

env.setdefault("GRAAL_PYTHONHOME", _dev_pythonhome())

delete_bad_env_keys(env)

check_vm_env = env.get('GRAALPYTHON_MUST_USE_GRAAL', False)

if check_vm_env:

if check_vm_env == '1':

check_vm(must_be_jvmci=True)

elif check_vm_env == '0':

check_vm()

if minimal:

x = [x for x in SUITE.dists if x.name == "GRAALPYTHON"][0]

dists = [dep for dep in x.deps if dep.isJavaProject() or dep.isJARDistribution()]

# Hack: what we should just do is + ['GRAALPYTHON_VERSIONS_MAIN'] and let MX figure out

# the class-path and other VM arguments necessary for it. However, due to a bug in MX,

# LayoutDirDistribution causes an exception if passed to mx.get_runtime_jvm_args,

# because it does not properly initialize its super class ClasspathDependency, see MX PR: 1665.

ver_dep = mx.dependency('GRAALPYTHON_VERSIONS_MAIN').get_output()

cp_prefix = ver_dep if cp_prefix is None else (ver_dep + os.pathsep + cp_prefix)

else:

dists = ['GRAALPYTHON']

dists += ['GRAALPYTHON-LAUNCHER']

vm_args, graalpython_args = mx.extract_VM_args(args, useDoubleDash=True, defaultAllVMArgs=False)

if minimal:

vm_args.insert(0, f"-Dorg.graalvm.language.python.home={_dev_pythonhome()}")

graalpython_args, additional_dists = _extract_graalpython_internal_options(graalpython_args)

dists += additional_dists

if extra_dists:

dists += extra_dists

if not CI:

# Try eagerly to include tools for convenience when running Python

if not mx.suite("tools", fatalIfMissing=False):

SUITE.import_suite("tools", version=None, urlinfos=None, in_subdir=True)

if mx.suite("tools", fatalIfMissing=False):

for tool in ["CHROMEINSPECTOR", "TRUFFLE_COVERAGE"]:

if os.path.exists(mx.suite("tools").dependency(tool).path):

dists.append(tool)

graalpython_args.insert(0, '--experimental-options=true')

vm_args += mx.get_runtime_jvm_args(dists, jdk=jdk, cp_prefix=cp_prefix, cp_suffix=cp_suffix, force_cp=True)

if not jdk:

jdk = get_jdk()

# default: assertion checking is enabled

if extra_vm_args is None or '-da' not in extra_vm_args:

vm_args += ['-ea', '-esa']

if extra_vm_args:

vm_args += extra_vm_args

vm_args.append(main_class)

path = os.environ.get("PATH", "")

if mx.is_linux() and not shutil.which("patchelf"):

venv = Path(SUITE.get_output_root()).absolute() / "patchelf-venv"

path += os.pathsep + str(venv / "bin")

if not shutil.which("patchelf", path=path):

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building patchelf-venv with {sys.executable}... [patchelf not found on PATH]")

t0 = time.time()

subprocess.check_call([sys.executable, "-m", "venv", str(venv)])

subprocess.check_call([str(venv / "bin" / "pip"), "install", "patchelf"])

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building patchelf-venv with {sys.executable}... [duration: {time.time() - t0}]")

if mx.is_windows() and not shutil.which("delvewheel"):

venv = Path(SUITE.get_output_root()).absolute() / "delvewheel-venv"

path += os.pathsep + str(venv / "Scripts")

if not shutil.which("delvewheel", path=path):

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building delvewheel-venv with {sys.executable}... [delvewheel not found on PATH]")

t0 = time.time()

subprocess.check_call([sys.executable, "-m", "venv", str(venv)])

subprocess.check_call([str(venv / "Scripts" / "pip.exe"), "install", "delvewheel"])

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building delvewheel-venv with {sys.executable}... [duration: {time.time() - t0}]")

"""

path = get_path_with_patchelf()

args = [] if ars is None else ars

@dataclass

class TestConfig:

identifier: str

args: list

useResources: bool

reportConfig: bool = report

def __str__(self):

return f"args={self.args!r}, useResources={self.useResources}, report={self.reportConfig}"

configs = []

skip_leak_tests = False

if "--no-leak-tests" in args:

skip_leak_tests = True

args.remove("--no-leak-tests")

if is_collecting_coverage():

skip_leak_tests = True

vm_args = ['-Dpolyglot.engine.WarnInterpreterOnly=false']

if BYTECODE_DSL_INTERPRETER:

vm_args.append("-Dpython.EnableBytecodeDSLInterpreter=true")

# Note: we must use filters instead of --regex so that mx correctly processes the unit test configs,

# but it is OK to apply --regex on top of the filters

graalpy_tests = ['com.oracle.graal.python.test', 'com.oracle.graal.python.pegparser.test', 'org.graalvm.python.embedding.test']

configs += [

TestConfig("junit", vm_args + graalpy_tests + args, True),

TestConfig("junit", vm_args + graalpy_tests + args, False),

]

if '--regex' not in args:

async_regex = ['--regex', r'com\.oracle\.graal\.python\.test\.integration\.advanced\.AsyncActionThreadingTest']

configs.append(TestConfig("async", vm_args + ['-Dpython.AutomaticAsyncActions=false', 'com.oracle.graal.python.test', 'org.graalvm.python.embedding.test'] + async_regex + args, True, False))

else:

skip_leak_tests = True

for c in configs:

mx.log(f"Python JUnit tests configuration: {c}")

PythonMxUnittestConfig.useResources = c.useResources

with set_env(PATH=path):

mx_unittest.unittest(c.args, test_report_tags=({"task": f"punittest-{c.identifier}-{'w' if c.useResources else 'wo'}-resources"} if c.reportConfig else None))

if skip_leak_tests:

return

# test leaks with Python code only

run_leak_launcher(["--code", "pass", ])

run_leak_launcher(["--repeat-and-check-size", "250", "--null-stdout", "--code", "print('hello')"])

# test leaks when some C module code is involved

run_leak_launcher(["--code", 'import _testcapi, mmap, bz2; print(memoryview(b"").nbytes)'])

# test leaks with shared engine Python code only

run_leak_launcher(["--shared-engine", "--code", "pass"])

run_leak_launcher(["--shared-engine", "--repeat-and-check-size", "250", "--null-stdout", "--code", "print('hello')"])

# test leaks with shared engine when some C module code is involved

run_leak_launcher(["--shared-engine", "--code", 'import _testcapi, mmap, bz2; print(memoryview(b"").nbytes)'])

run_leak_launcher(["--shared-engine", "--code", '[10, 20]', "--python.UseNativePrimitiveStorageStrategy=true",

"--forbidden-class", "com.oracle.graal.python.runtime.sequence.storage.NativePrimitiveSequenceStorage",

"--forbidden-class", "com.oracle.graal.python.runtime.native_memory.NativePrimitiveReference"])

run_leak_launcher(["--code", '[10, 20]', "--python.UseNativePrimitiveStorageStrategy=true",

"--forbidden-class", "com.oracle.graal.python.runtime.sequence.storage.NativePrimitiveSequenceStorage",

"python-liblzma",

"python-libzsupport",

"python-libposix",

junit = 'python-junit'

junit_maven = 'python-junit-maven'

junit_maven_isolates = 'python-junit-polyglot-isolates'

jvmbuild = 'python-jvm-build'

unittest = 'python-unittest'

unittest_cpython = 'python-unittest-cpython'

unittest_sandboxed = 'python-unittest-sandboxed'

unittest_multi = 'python-unittest-multi-context'

unittest_jython = 'python-unittest-jython'

unittest_arrow = 'python-unittest-arrow-storage'

unittest_hpy = 'python-unittest-hpy'

unittest_hpy_sandboxed = 'python-unittest-hpy-sandboxed'

unittest_posix = 'python-unittest-posix'

unittest_standalone = 'python-unittest-standalone'

tagged = 'python-tagged-unittest'

svmbuild = 'python-svm-build'

svmunit = 'python-svm-unittest'

svmunit_sandboxed = 'python-svm-unittest-sandboxed'

graalvm = 'python-graalvm'

embedding = 'python-standalone-embedding'

graalvm_sandboxed = 'python-graalvm-sandboxed'

svm = 'python-svm'

native_image_embedder = 'python-native-image-embedder'

license = 'python-license'

language_checker = 'python-language-checker'

if not os.environ.get("JDT"):

os.environ["JDT"] = "builtin"

if not os.environ.get("ECLIPSE_EXE"):

find_eclipse()

if "--tags" not in args:

args += ["--tags"]

tags = ["style"]

for x in dir(GraalPythonTags):

v = getattr(GraalPythonTags, x)

if isinstance(v, str) and v.startswith("python-"):

if "sandboxed" not in v:

tags.append(v)

args.append(",".join(tags))

mx.log("Running mx python-gate " + " ".join(args))

pardir = os.path.abspath(os.path.join(SUITE.dir, ".."))

for f in [os.path.join(SUITE.dir, f)

for f in os.listdir(SUITE.dir)] + [os.path.join(pardir, f)

for f in os.listdir(pardir)]:

if os.path.basename(f) == "eclipse" and os.path.isdir(f):

mx.log("Automatically choosing %s for Eclipse" % f)

eclipse_exe = os.path.join(f, f"eclipse{'.exe' if mx.is_windows() else ''}")

if os.path.exists(eclipse_exe):

os.environ["ECLIPSE_EXE"] = eclipse_exe

"""Temporarily set the process environment variables"""

old_environ = dict(os.environ)

for k, v in environ.items():

if v is None:

if k in os.environ:

del os.environ[k]

else:

os.environ[k] = v

try:

yield

finally:

os.environ.clear()

assert standalone_type in ['native', 'jvm']

assert not (enterprise and dev), "EE dev standalones are not implemented yet"

jdk_version = mx.get_jdk().version

# Check if GRAALPY_HOME points to some compatible pre-built GraalPy standalone

python_home = os.environ.get("GRAALPY_HOME", None)

if python_home:

python_home = os.path.abspath(glob.glob(python_home)[0])

mx.log("Using GraalPy standalone from GRAALPY_HOME: " + python_home)

# Try to verify that we're getting what we expect:

has_java = os.path.exists(os.path.join(python_home, 'jvm', 'bin', mx.exe_suffix('java')))

if has_java != (standalone_type == 'jvm'):

mx.abort(f"GRAALPY_HOME is not compatible with the requested distribution type.\n"

f"jvm/bin/java exists?: {has_java}, requested type={standalone_type}.")

line = ''

with open(os.path.join(python_home, 'release'), 'r') as f:

while 'JAVA_VERSION=' not in line:

line = f.readline()

if 'JAVA_VERSION=' not in line:

mx.abort(f"GRAALPY_HOME does not contain 'release' file. Cannot check Java version.")

actual_jdk_version = mx.VersionSpec(line.strip('JAVA_VERSION=').strip(' "\n\r'))

if actual_jdk_version != jdk_version:

mx.abort(f"GRAALPY_HOME is not compatible with the requested JDK version.\n"

f"actual version: '{actual_jdk_version}', version string: {line}, requested version: {jdk_version}.")

launcher = os.path.join(python_home, 'bin', _graalpy_launcher())

out = mx.OutputCapture()

mx.run([launcher, "-c", "print(__graalpython__.is_bytecode_dsl_interpreter)"], nonZeroIsFatal=False, out=out, err=out)

is_bytecode_dsl_interpreter = out.data.strip() == "True"

if is_bytecode_dsl_interpreter != BYTECODE_DSL_INTERPRETER:

requested = "Bytecode DSL" if BYTECODE_DSL_INTERPRETER else "Manual"

actual = "Bytecode DSL" if is_bytecode_dsl_interpreter else "Manual"

mx.abort(f"GRAALPY_HOME is not compatible with requested interpreter kind ({requested=}, {actual=})")

return python_home

# Build

if standalone_type == 'jvm':

if dev:

env_file = 'jvm'

else:

env_file = 'jvm-ee-libgraal' if enterprise else 'jvm-ce-libgraal'

standalone_dist = 'GRAALPY_JVM_STANDALONE'

if "GraalVM" in subprocess.check_output([get_jdk().java, '-version'], stderr=subprocess.STDOUT, universal_newlines=True):

env_file = ""

else:

env_file = 'native-ee' if enterprise else 'native-ce'

standalone_dist = 'GRAALPY_NATIVE_STANDALONE'

mx_args = ['-p', SUITE.dir, *(['--env', env_file] if env_file else [])]

mx_args.append("--extra-image-builder-argument=-g")

if BUILD_NATIVE_IMAGE_WITH_ASSERTIONS:

mx_args.append("--extra-image-builder-argument=-ea")

if mx_gate.get_jacoco_agent_args() or (build and not DISABLE_REBUILD):

mx_build_args = mx_args

if BYTECODE_DSL_INTERPRETER:

mx_build_args = mx_args + ["--extra-image-builder-argument=-Dpython.EnableBytecodeDSLInterpreter=true"]

# This build is purposefully done without the LATEST_JAVA_HOME in the

# environment, so we can build JVM standalones on an older Graal JDK

run_mx(mx_build_args + ["build", "--target", standalone_dist])

python_home = os.path.join(SUITE.dir, 'mxbuild', f"{mx.get_os()}-{mx.get_arch()}", standalone_dist)

if dev and standalone_type == 'native':

debuginfo = os.path.join(SUITE.dir, 'mxbuild', f"{mx.get_os()}-{mx.get_arch()}", "libpythonvm", "libpythonvm.so.debug")

if os.path.exists(debuginfo):

shutil.copy(debuginfo, os.path.join(python_home, 'lib'))

assert standalone_type in ['native', 'jvm']

if standalone_type == 'native' and mx_gate.get_jacoco_agent_args():

return graalpy_standalone('jvm', enterprise=enterprise, dev=dev, build=build)

home = graalpy_standalone_home(standalone_type, enterprise=enterprise, dev=dev, build=build)

launcher = os.path.join(home, 'bin', _graalpy_launcher())

jdk_version = mx.get_jdk().version

# Check if GRAAL_JDK_HOME points to some compatible pre-built gvm

graal_jdk_home = os.environ.get("GRAAL_JDK_HOME", None)

if graal_jdk_home:

graal_jdk_home = os.path.abspath(glob.glob(graal_jdk_home)[0])

if sys.platform == "darwin":

jdk_home_subdir = os.path.join(graal_jdk_home, 'Contents', 'Home')

if os.path.exists(jdk_home_subdir):

graal_jdk_home = jdk_home_subdir

mx.log("Using Graal from GRAAL_JDK_HOME: " + graal_jdk_home)

# Try to verify that we're getting what we expect:

has_java = os.path.exists(os.path.join(graal_jdk_home, 'bin', mx.exe_suffix('java')))

if not has_java:

mx.abort(f"GRAAL_JDK_HOME does not contain java executable.")

release = os.path.join(graal_jdk_home, 'release')

if not os.path.exists(release):

mx.abort(f"No 'release' file in GRAAL_JDK_HOME.")

java_version = None

with open(release, 'r') as f:

while not java_version:

line = f.readline()

if 'JAVA_VERSION=' in line:

java_version = line

if not java_version:

mx.abort(f"Could not check Java version in GRAAL_JDK_HOME 'release' file.")

actual_jdk_version = mx.VersionSpec(java_version.strip('JAVA_VERSION=').strip(' "\n\r'))

if actual_jdk_version != jdk_version:

mx.abort(f"GRAAL_JDK_HOME is not compatible with the requested JDK version.\n"

f"actual version: '{actual_jdk_version}', version string: {java_version}, requested version: {jdk_version}.")

return graal_jdk_home

jdk_major_version = mx.get_jdk().version.parts[0]

if enterprise:

mx_args = ['-p', os.path.join(mx.suite('truffle').dir, '..', '..', 'graal-enterprise', 'vm-enterprise'), '--env', 'ee']

edition = ""

else:

mx_args = ['-p', os.path.join(mx.suite('truffle').dir, '..', 'vm'), '--env', 'ce']

edition = "COMMUNITY_"

if not DISABLE_REBUILD:

run_mx(mx_args + ["build", "--dep", f"GRAALVM_{edition}JAVA{jdk_major_version}"], env={**os.environ, **LATEST_JAVA_HOME})

out = mx.OutputCapture()

run_mx(mx_args + ["graalvm-home"], out=out)

env = {**os.environ.copy(), **(env or {})}

m2_cache = get_maven_cache()

if m2_cache:

mvn_repo_local = f'-Dmaven.repo.local={m2_cache}'

maven_opts = env.get('MAVEN_OPTS')

maven_opts = maven_opts + " " + mvn_repo_local if maven_opts else mvn_repo_local

env['MAVEN_OPTS'] = maven_opts

mx.log(f'Added {mvn_repo_local} to MAVEN_OPTS={maven_opts}')

run_mx_args = [

'-p',

os.path.join(mx.suite('truffle').dir, '..', 'vm'),

'--dy',

'graalpython',

]

if not DISABLE_REBUILD:

# build GraalPy and all the necessary dependencies, so that we can deploy them

run_mx(run_mx_args + ["build"], env={**env, **LATEST_JAVA_HOME})

# deploy maven artifacts

version = GRAAL_VERSION

path = os.path.join(SUITE.get_mx_output_dir(), 'public-maven-repo')

licenses = ['EPL-2.0', 'PSF-License', 'GPLv2-CPE', 'ICU,GPLv2', 'BSD-simplified', 'BSD-new', 'UPL', 'MIT', 'GFTC']

deploy_args = run_mx_args + [

'maven-deploy',

'--tags=public',

'--all-suites',

'--all-distribution-types',

f'--version-string={version}',

'--validate=none',

'--licenses', ','.join(licenses),

'--suppress-javadoc',

'local',

pathlib.Path(path).as_uri(),

]

if not DISABLE_REBUILD:

mx.rmtree(path, ignore_errors=True)

os.mkdir(path)

run_mx(deploy_args, env={**env, **LATEST_JAVA_HOME})

"""Returns the path to GraalPy from 'jvm' standalone dev build. Also builds the standalone."""

launcher = graalpy_standalone('jvm', dev=True)

mx.log(launcher)

if mx_gate.get_jacoco_agent_args():

# patch our launchers created under jacoco to also run with jacoco.

# do not use is_collecting_coverage() here, we only want to patch when

# jacoco agent is requested.

quote = shlex.quote if sys.platform != 'win32' else lambda x: x

def graalvm_vm_arg(java_arg):

if java_arg.startswith("@") and os.path.exists(java_arg[1:]):

with open(java_arg[1:], "r") as f:

java_arg = f.read()

assert java_arg[0] == "-", java_arg

return quote(f'--vm.{java_arg[1:]}')

agent_args = ' '.join(graalvm_vm_arg(arg) for arg in mx_gate.get_jacoco_agent_args() or [])

# We need to make sure the arguments get passed to subprocesses, so we create a temporary launcher

# with the arguments. We also disable compilation, it hardly helps for this use case

original_launcher = os.path.abspath(os.path.realpath(launcher))

if sys.platform != 'win32':

coverage_launcher = original_launcher + '.sh'

preamble = '#!/bin/sh'

pass_args = '"$@"'

else:

coverage_launcher = original_launcher.replace('.exe', '.cmd')

# Windows looks for libraries on PATH, we need to add the jvm bin dir there or it won't find the instrumentation dlls

jvm_bindir = os.path.join(os.path.dirname(os.path.dirname(original_launcher)), 'jvm', 'bin')

preamble = f'@echo off\nset PATH=%PATH%;{jvm_bindir}'

pass_args = '%*'

with open(coverage_launcher, "w") as f:

f.write(f'{preamble}\n')

exe_arg = quote(f"--python.Executable={coverage_launcher}")

f.write(f'{original_launcher} --jvm {exe_arg} {agent_args} {pass_args}\n')

if sys.platform != 'win32':

os.chmod(coverage_launcher, 0o775)

mx.log(f"Replaced {launcher} with {coverage_launcher} to collect coverage")

launcher = coverage_launcher

"""Returns the path to GraalPy native image from 'native' standalone dev build.

if mx_gate.get_jacoco_agent_args():

return python_jvm()

launcher = graalpy_standalone('native', dev=True)

mx.log(launcher)

# help is delegated to the runner, it will fake the mx-specific options as well

parser = ArgumentParser(prog='mx graalpytest', add_help=False)

parser.add_argument('--python')

parser.add_argument('--svm', action='store_true')

args, unknown_args = parser.parse_known_args(args)

env = extend_os_env(

MX_GRAALPYTEST='1',

PYTHONHASHSEED='0',

)

python_args = []

runner_args = []

for arg in unknown_args:

if arg.startswith(('--python.', '--engine.', '--vm.', '--inspect', '--log.', '--experimental-options')):

python_args.append(arg)

else:

runner_args.append(arg)

# if we got a binary path it's most likely CPython, so don't add graalpython args

is_graalpy = False

python_binary = args.python

if not python_binary:

is_graalpy = True

python_args += ["--experimental-options=true", "--python.EnableDebuggingBuiltins"]

if args.svm:

python_binary = graalpy_standalone_native()

elif 'graalpy' in os.path.basename(python_binary) or 'mxbuild' in python_binary:

is_graalpy = True

gp_args = ["--vm.ea", "--vm.esa", "--experimental-options=true", "--python.EnableDebuggingBuiltins"]

mx.log(f"Executable seems to be GraalPy, prepending arguments: {gp_args}")

python_args += gp_args

if is_graalpy and BYTECODE_DSL_INTERPRETER:

python_args.insert(0, "--vm.Dpython.EnableBytecodeDSLInterpreter=true")

runner_args.append(f'--subprocess-args={shlex.join(python_args)}')

if is_graalpy:

runner_args.append(f'--append-path={os.path.join(_dev_pythonhome(), "lib-python", "3")}')

cmd_args = [*python_args, _python_test_runner(), 'run', *runner_args]

delete_bad_env_keys(env)

if python_binary:

try:

result = run([python_binary, *cmd_args], nonZeroIsFatal=True, env=env)

print(f"back from mx.run, returning {result}")

return result

except BaseException as e:

print(f"Exception raised: {e}")

else:

exclude = [] if exclude is None else exclude

paths = paths or [_python_unittest_root()]

def is_included(path):

if path.endswith(".py"):

path = path.replace("\\", "/")

basename = os.path.basename(path)

return (

basename.startswith("test_")

and basename not in exclude

and not any(fnmatch.fnmatch(path, pat) for pat in exclude)

)

return False

testfiles = []

for path in paths:

if not os.path.exists(path):

# allow paths relative to the test root

path = os.path.join(_python_unittest_root(), path)

if os.path.isfile(path):

testfiles.append(path)

else:

for testfile in glob.glob(os.path.join(path, "**/test_*.py")):

if is_included(testfile):

testfiles.append(testfile.replace("\\", "/"))

for testfile in glob.glob(os.path.join(path, "test_*.py")):

if is_included(testfile):

testfiles.append(testfile.replace("\\", "/"))

use_pytest=False, cwd=None, lock=None, out=None, err=None, nonZeroIsFatal=True, timeout=None,

report=False, parallel=None, runner_args=None):

if lock:

lock.acquire()

if parallel is None:

parallel = 4 if paths is None else 1

if sys.platform == 'win32':

# Windows machines don't seem to have much memory

parallel = min(parallel, 2)

parallelism = str(min(os.cpu_count(), parallel))

args = args or []

args = [