# Copyright (c) 2018, 2023, Oracle and/or its affiliates.

# Copyright (c) 2013, Regents of the University of California

#

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without modification, are

# permitted provided that the following conditions are met:

#

# 1. Redistributions of source code must retain the above copyright notice, this list of

# conditions and the following disclaimer.

# 2. Redistributions in binary form must reproduce the above copyright notice, this list of

# conditions and the following disclaimer in the documentation and/or other materials provided

# with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE

# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

# OF THE POSSIBILITY OF SUCH DAMAGE.

from __future__ import print_function

import contextlib

import datetime

import fnmatch

import getpass

import glob

import itertools

import json

import os

import re

import shlex

import shutil

import sys

import time

from functools import wraps

HPY_IMPORT_ORPHAN_BRANCH_NAME = "hpy-import"

if sys.version_info[0] < 3:

raise RuntimeError("The build scripts are no longer compatible with Python 2")

import tempfile

import urllib.request as urllib_request

from argparse import ArgumentParser

import mx

import mx_benchmark

import mx_gate

import mx_unittest

import mx_sdk

import mx_subst

import mx_graalpython_bisect

import mx_graalpython_import

import mx_graalpython_python_benchmarks

# re-export custom mx project classes so they can be used from suite.py

from mx_cmake import CMakeNinjaProject #pylint: disable=unused-import

from mx_gate import Task

from mx_graalpython_bench_param import PATH_MESO, BENCHMARKS, WARMUP_BENCHMARKS, JBENCHMARKS, JAVA_DRIVER_BENCHMARKS

from mx_graalpython_benchmark import PythonBenchmarkSuite, python_vm_registry, CPythonVm, PyPyVm, JythonVm, \

GraalPythonVm, \

CONFIGURATION_DEFAULT, CONFIGURATION_SANDBOXED, CONFIGURATION_NATIVE, \

CONFIGURATION_DEFAULT_MULTI, CONFIGURATION_SANDBOXED_MULTI, CONFIGURATION_NATIVE_MULTI, \

CONFIGURATION_DEFAULT_MULTI_TIER, CONFIGURATION_NATIVE_MULTI_TIER, \

PythonInteropBenchmarkSuite, PythonVmWarmupBenchmarkSuite, \

CONFIGURATION_INTERPRETER, CONFIGURATION_INTERPRETER_MULTI, CONFIGURATION_NATIVE_INTERPRETER, \

CONFIGURATION_NATIVE_INTERPRETER_MULTI, PythonJavaEmbeddingBenchmarkSuite, python_java_embedding_vm_registry, \

GraalPythonJavaDriverVm, CONFIGURATION_JAVA_EMBEDDING_INTERPRETER_MULTI_SHARED, \

CONFIGURATION_JAVA_EMBEDDING_INTERPRETER_MULTI, CONFIGURATION_JAVA_EMBEDDING_MULTI_SHARED, \

CONFIGURATION_JAVA_EMBEDDING_MULTI

if not sys.modules.get("__main__"):

# workaround for pdb++

sys.modules["__main__"] = type(sys)("<empty>")

SUITE = mx.suite('graalpython')

SUITE_COMPILER = mx.suite("compiler", fatalIfMissing=False)

SUITE_SULONG = mx.suite("sulong")

GRAAL_VERSION = ".".join(SUITE.suiteDict['version'].split('.')[:2])

PYTHON_VERSION = "3.10"

GRAALPYTHON_MAIN_CLASS = "com.oracle.graal.python.shell.GraalPythonMain"

SANDBOXED_OPTIONS = ['--llvm.managed', '--llvm.deadPointerProtection=MASK', '--llvm.partialPointerConversion=false', '--python.PosixModuleBackend=java']

# Allows disabling rebuild for some mx commands such as graalpytest

DISABLE_REBUILD = os.environ.get('GRAALPYTHON_MX_DISABLE_REBUILD', False)

_COLLECTING_COVERAGE = False

def is_collectiong_coverage():

return bool(mx_gate.get_jacoco_agent_args() or _COLLECTING_COVERAGE)

if os.environ.get("CI") == "true" and not os.environ.get("GRAALPYTEST_FAIL_FAST"):

os.environ["GRAALPYTEST_FAIL_FAST"] = "true"

def _sibling(filename):

return os.path.join(os.path.dirname(__file__), filename)

def _get_core_home():

return os.path.join(SUITE.dir, "graalpython", "lib-graalpython")

def _get_stdlib_home():

return os.path.join(SUITE.dir, "graalpython", "lib-python", "3")

def _get_capi_home():

return mx.dependency("com.oracle.graal.python.cext").get_output_root()

def _get_jni_home():

return mx.distribution("GRAALPYTHON_JNI").get_output()

def _extract_graalpython_internal_options(args):

non_internal = []

additional_dists = []

for arg in args:

# Class path extensions

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

additional_dists += [arg[10:]]

else:

non_internal += [arg]

return non_internal, additional_dists

def delete_bad_env_keys(env):

for k in ["SSL_CERT_FILE", "REQUESTS_CA_BUNDLE"]:

if k in env:

del env[k]

def check_vm(vm_warning=True, must_be_jvmci=False):

if not SUITE_COMPILER:

if must_be_jvmci:

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

sys.exit(1)

if vm_warning:

mx.log('** warning ** : graal compiler was not found!! Executing using standard VM..')

def get_jdk():

if SUITE_COMPILER:

tag = 'jvmci'

else:

tag = None

return mx.get_jdk(tag=tag)

def full_python(args, **kwargs):

"""run python from graalvm (unless kwargs are given)"""

if kwargs:

return python(args, **kwargs)

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 not any(arg.startswith('--experimental-options') for arg in args):

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

if mx._opts.java_dbg_port:

args.insert(0, f"--vm.agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=127.0.0.1:{mx._opts.java_dbg_port}")

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")

import mx_sdk_vm_impl

home = mx_sdk_vm_impl.graalvm_home()

mx.run([os.path.join(home, "bin", f"graalpy{'.cmd' if mx.is_windows() else ''}")] + args)

def python(args, **kwargs):

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

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

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

do_run_python(args, **kwargs)

def do_run_python(args, extra_vm_args=None, env=None, jdk=None, extra_dists=None, cp_prefix=None, cp_suffix=None, main_class=GRAALPYTHON_MAIN_CLASS, minimal=False, **kwargs):

experimental_opt_added = False

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")

experimental_opt_added = True

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

args.insert(0, "--python.JNIHome=" + _get_jni_home())

if not experimental_opt_added:

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()]

else:

dists = ['GRAALPYTHON']

dists += ['TRUFFLE_NFI', 'SULONG_NATIVE']

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 os.environ.get("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)

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)

return mx.run_java(vm_args + graalpython_args, jdk=jdk, env=env, **kwargs)

def _pythonhome_context():

return set_env(GRAAL_PYTHONHOME=_pythonhome())

def _pythonhome():

return mx.dependency("GRAALPYTHON_GRAALVM_SUPPORT").get_output()

def _dev_pythonhome_context():

home = os.environ.get("GRAAL_PYTHONHOME", _dev_pythonhome())

return set_env(GRAAL_PYTHONHOME=home)

def _dev_pythonhome():

return os.path.join(SUITE.dir, "graalpython")

def punittest(ars, report=False):

"""

Runs GraalPython junit tests and memory leak tests, which can be skipped using --no-leak-tests.

Any other arguments are forwarded to mx's unittest function. If there is no explicit test filter

in the arguments array, then we append filter that includes all GraalPython junit tests.

"""

args = []

args2 = []

skip_leak_tests = False

if "--regex" not in ars:

args += ['--regex', r'(graal\.python)|(com\.oracle\.truffle\.tck\.tests)']

args2 += ['-Dpython.AutomaticAsyncActions=false', '--regex', r'com\.oracle\.graal\.python\.test\.advance\.AsyncActionThreadingTest']

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

skip_leak_tests = True

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

args += ars

args2 += ars

with _pythonhome_context():

mx_unittest.unittest(args, test_report_tags=({"task": "punittest"} if report else None))

if len(args2) > len(ars):

mx_unittest.unittest(args2)

if skip_leak_tests:

return

common_args = ["--lang", "python",

"--forbidden-class", "com.oracle.graal.python.builtins.objects.object.PythonObject",

"--python.ForceImportSite", "--python.TRegexUsesSREFallback=false"]

if not all([

# test leaks with Python code only

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

# test leaks when some C module code is involved

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

# test leaks with shared engine Python code only

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

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

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

]):

mx.abort(1)

PYTHON_ARCHIVES = ["GRAALPYTHON_GRAALVM_SUPPORT"]

PYTHON_NATIVE_PROJECTS = ["com.oracle.graal.python.cext"]

def nativebuild(args):

"Build the non-Java Python projects and archives"

mx.build(["--dependencies", ",".join(PYTHON_NATIVE_PROJECTS + PYTHON_ARCHIVES)])

def nativeclean(args):

"Clean the non-Java Python projects"

mx.clean(["--dependencies", ",".join(PYTHON_NATIVE_PROJECTS + PYTHON_ARCHIVES)])

def python3_unittests(args):

"""run the cPython stdlib unittests"""

mx.run([sys.executable, "graalpython/com.oracle.graal.python.test/src/python_unittests.py", "-v"] + args)

def compare_unittests(args):

"""compare the output of two runs of the cPython stdlib unittests"""

mx.run([sys.executable, "graalpython/com.oracle.graal.python.test/src/compare_unittests.py", "-v"] + args)

def run_cpython_test(raw_args):

test_args = ['-v']

parser = ArgumentParser()

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

parser.add_argument('--gvm', dest='vm', action='store_const', const='gvm')

parser.add_argument('--svm', dest='vm', action='store_const', const='svm')

parser.add_argument('-k', dest='tags', action='append')

parser.add_argument('globs', nargs='+')

args, rest_args = parser.parse_known_args(raw_args)

testfiles = []

for g in args.globs:

testfiles += glob.glob(os.path.join(SUITE.dir, "graalpython/lib-python/3/test", f"{g}.py"))

testfiles += glob.glob(os.path.join(SUITE.dir, "graalpython/lib-python/3/test", g, "__init__.py"))

if not args.all:

test_tags = get_test_tags(args.globs)

if args.tags:

user_tags = [tag if '*' in tag else f'*{tag}*' for tag in args.tags]

test_tags = [tag for tag in test_tags if any(fnmatch.fnmatch(tag.replace('*', ''), user_tag) for user_tag in user_tags)]

if not test_tags:

sys.exit("No tags matched")

else:

test_tags = args.tags

for tag in test_tags or ():

test_args += ['-k', tag]

python_args = rest_args + [

os.path.join(SUITE.dir, "graalpython/com.oracle.graal.python.test/src/tests/run_cpython_test.py"),

] + test_args + testfiles

if args.vm:

env = os.environ.copy()

delete_bad_env_keys(env)

vm = python_gvm() if args.vm == 'gvm' else python_svm()

with _dev_pythonhome_context():

mx.run([vm, '--vm.ea', f'--python.CAPI={_get_capi_home()}'] + python_args, env=env)

else:

do_run_python(python_args)

def get_test_tags(globs):

sys.path += ["graalpython/com.oracle.graal.python.test/src/tests", "graalpython/lib-python/3"]

os.environ['ENABLE_CPYTHON_TAGGED_UNITTESTS'] = 'true'

try:

import test_tagged_unittests

collected = []

for name, tags in test_tagged_unittests.collect_working_tests():

if any(fnmatch.fnmatch(name, g) for g in globs):

collected += tags

return collected

finally:

del os.environ['ENABLE_CPYTHON_TAGGED_UNITTESTS']

def retag_unittests(args):

"""run the cPython stdlib unittests"""

parser = ArgumentParser('mx python-retag-unittests')

parser.add_argument('--upload-results-to')

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

parser.add_argument('-debug-java', action='store_true')

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

parsed_args, remaining_args = parser.parse_known_args(args)

env = os.environ.copy()

env.update(

ENABLE_CPYTHON_TAGGED_UNITTESTS="true",

PYTHONPATH=os.path.join(_dev_pythonhome(), 'lib-python/3'),

)

delete_bad_env_keys(env)

args = [

'--experimental-options=true',

'--python.CatchAllExceptions=true',

]

if parsed_args.inspect:

args.append('--inspect')

if parsed_args.debug_java:

args.append('-debug-java')

args += [

'graalpython/com.oracle.graal.python.test/src/tests/test_tagged_unittests.py',

'--retag'

]

vm = python_svm() if not parsed_args.jvm else python_gvm()

if parsed_args.jvm:

args += ['-ea']

mx.run([vm] + args + remaining_args, env=env)

if parsed_args.upload_results_to:

with tempfile.TemporaryDirectory(prefix='graalpython-retagger-') as d:

filename = os.path.join(d, 'unittest-tags-{}.tar.bz2'.format(sys.platform))

mx.run(['tar', 'cJf', filename, 'graalpython/com.oracle.graal.python.test/src/tests/unittest_tags'])

mx.run(['scp', filename, parsed_args.upload_results_to.rstrip('/') + '/'])

def _read_tags(path='.'):

tags = set()

tagfiles = glob.glob(os.path.join(path, 'graalpython/com.oracle.graal.python.test/src/tests/unittest_tags/*.txt'))

for tagfile in tagfiles:

with open(tagfile) as f:

tags |= {(os.path.basename(tagfile), line.strip()) for line in f if line.strip()}

return tags

def _write_tags(tags, path='.'):

tagdir = os.path.join(path, 'graalpython/com.oracle.graal.python.test/src/tests/unittest_tags/')

tagfiles = glob.glob(os.path.join(path, 'graalpython/com.oracle.graal.python.test/src/tests/unittest_tags/*.txt'))

for file in tagfiles:

os.unlink(file)

for file, stags in itertools.groupby(sorted(tags), key=lambda x: x[0]):

with open(os.path.join(tagdir, file), 'w') as f:

for tag in stags:

f.write(tag[1] + '\n')

def _fetch_tags_for_platform(parsed_args, platform):

oldpwd = os.getcwd()

with tempfile.TemporaryDirectory(prefix='graalpython-update-tags-') as d:

os.chdir(d)

try:

tarfile = 'unittest-tags-{}.tar.bz2'.format(platform)

url = '{}/{}'.format(parsed_args.tags_directory_url.rstrip('/'), tarfile)

print(mx.colorize('Download from %s' % (url), color='magenta', bright=True, stream=sys.stdout))

mx.run(['curl', '-O', url])

out = mx.OutputCapture()

mx.run(['file', tarfile], out=out)

if 'HTML' in out.data:

if not mx.ask_yes_no('Download failed! please download %s manually to %s and type (y) '

'to continue.' % (url, d), default='y'):

sys.exit(1)

os.mkdir(platform)

mx.run(['tar', 'xf', tarfile, '-C', platform])

return _read_tags(platform)

finally:

os.chdir(oldpwd)

def update_unittest_tags(args):

parser = ArgumentParser('mx python-update-unittest-tags')

parser.add_argument('tags_directory_url')

parser.add_argument('--untag', action='store_true', help="Allow untagging existing tests")

parsed_args = parser.parse_args(args)

current_tags = _read_tags()

linux_tags = _fetch_tags_for_platform(parsed_args, 'linux')

darwin_tags = _fetch_tags_for_platform(parsed_args, 'darwin')

tag_exclusions = {

# This test times out in the gate even though it succeeds locally and in the retagger. Race condition?

('test_cprofile.txt', '*graalpython.lib-python.3.test.test_cprofile.CProfileTest.test_run_profile_as_module'),

# The following two try to read bytecode and fail randomly as our co_code is changing

('test_modulefinder.txt', '*graalpython.lib-python.3.test.test_modulefinder.ModuleFinderTest.test_bytecode'),

('test_modulefinder.txt', '*graalpython.lib-python.3.test.test_modulefinder.ModuleFinderTest.test_relative_imports_4'),

# Temporarily disabled due to object identity or race condition (GR-24863)

('test_weakref.txt', '*graalpython.lib-python.3.test.test_weakref.MappingTestCase.test_threaded_weak_key_dict_deepcopy'),

# Temporarily disabled due to transient failures (GR-30641)

('test_import.txt', '*graalpython.lib-python.3.test.test_import.__init__.ImportTests.test_concurrency'),

# Disabled since this fails on Darwin when run in parallel with many other tests

('test_imaplib.txt', '*graalpython.lib-python.3.test.test_imaplib.NewIMAPSSLTests.test_login_cram_md5_bytes'),

('test_imaplib.txt', '*graalpython.lib-python.3.test.test_imaplib.NewIMAPSSLTests.test_login_cram_md5_plain_text'),

('test_imaplib.txt', '*graalpython.lib-python.3.test.test_imaplib.NewIMAPSSLTests.test_valid_authentication_plain_text'),

('test_imaplib.txt', '*graalpython.lib-python.3.test.test_imaplib.NewIMAPTests.test_login_cram_md5_bytes'),

('test_imaplib.txt', '*graalpython.lib-python.3.test.test_imaplib.NewIMAPTests.test_login_cram_md5_plain_text'),

('test_poplib.txt', '*graalpython.lib-python.3.test.test_poplib.TestPOP3_TLSClass.test_noop'),

('test_poplib.txt', '*graalpython.lib-python.3.test.test_poplib.TestPOP3_TLSClass.test_pass_'),

('test_poplib.txt', '*graalpython.lib-python.3.test.test_poplib.TestPOP3_TLSClass.test_apop_normal'),

('test_poplib.txt', '*graalpython.lib-python.3.test.test_poplib.TestPOP3_TLSClass.test_capa'),

('test_poplib.txt', '*graalpython.lib-python.3.test.test_poplib.TestPOP3_TLSClass.test_dele'),

# Disabled because these tests hang on Darwin

('test_logging.txt', '*graalpython.lib-python.3.test.test_logging.ConfigDictTest.test_listen_config_1_ok'),

('test_logging.txt', '*graalpython.lib-python.3.test.test_logging.ConfigDictTest.test_listen_config_10_ok'),

('test_logging.txt', '*graalpython.lib-python.3.test.test_logging.ConfigDictTest.test_listen_verify'),

# GC-related transients

('test_weakref.txt', '*graalpython.lib-python.3.test.test_weakref.MappingTestCase.test_weak_keyed_len_cycles'),

('test_weakref.txt', '*graalpython.lib-python.3.test.test_weakref.WeakMethodTestCase.test_callback_when_method_dead'),

('test_weakref.txt', '*graalpython.lib-python.3.test.test_weakref.WeakMethodTestCase.test_callback_when_object_dead'),

('test_weakref.txt', '*graalpython.lib-python.3.test.test_weakref.FinalizeTestCase.test_all_freed'),

('test_weakref.txt', '*graalpython.lib-python.3.test.test_weakref.ReferencesTestCase.test_equality'),

('test_copy.txt', '*graalpython.lib-python.3.test.test_copy.TestCopy.test_copy_weakkeydict'),

('test_copy.txt', '*graalpython.lib-python.3.test.test_copy.TestCopy.test_deepcopy_weakkeydict'),

('test_deque.txt', '*graalpython.lib-python.3.test.test_deque.TestBasic.test_container_iterator'),

('test_mmap.txt', '*graalpython.lib-python.3.test.test_mmap.MmapTests.test_weakref'),

# Disabled since code object comparison is not stable for us

('test_marshal.txt', '*graalpython.lib-python.3.test.test_marshal.InstancingTestCase.testModule'),

('test_marshal.txt', '*graalpython.lib-python.3.test.test_marshal.CodeTestCase.test_code'),

# Disabled since signaling isn't stable during parallel tests

('test_faulthandler.txt', '*graalpython.lib-python.3.test.test_faulthandler.FaultHandlerTests.test_sigbus'),

('test_faulthandler.txt', '*graalpython.lib-python.3.test.test_faulthandler.FaultHandlerTests.test_sigill'),

# Disabled due to transient failure

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_basic_script'),

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_basic_script_no_suffix'),

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_directory'),

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_directory_compiled'),

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_ipython_workaround'),

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_module_in_package'),

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_module_in_package_in_zipfile'),

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_package'),

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_package_compiled'),

('test_multiprocessing_main_handling.txt', '*graalpython.lib-python.3.test.test_multiprocessing_main_handling.SpawnCmdLineTest.test_zipfile'),

('test_multiprocessing_spawn.txt', '*graalpython.lib-python.3.test.test_multiprocessing_spawn.TestNoForkBomb.test_noforkbomb'),

('test_multiprocessing_spawn.txt', '*graalpython.lib-python.3.test.test_multiprocessing_spawn.WithProcessesTestProcess.test_active_children'),

('test_multiprocessing_spawn.txt', '*graalpython.lib-python.3.test.test_multiprocessing_spawn.WithProcessesTestProcess.test_error_on_stdio_flush_1'),

('test_multiprocessing_spawn.txt', '*graalpython.lib-python.3.test.test_multiprocessing_spawn.WithThreadsTestProcess.test_error_on_stdio_flush_1'),

('test_multiprocessing_spawn.txt', '*graalpython.lib-python.3.test.test_multiprocessing_spawn.WithThreadsTestProcess.test_error_on_stdio_flush_2'),

('test_multiprocessing_spawn.txt', '*graalpython.lib-python.3.test.test_multiprocessing_spawn._TestImportStar.test_import'),

('test_multiprocessing_spawn.txt', '*graalpython.lib-python.3.test.test_multiprocessing_spawn.WithProcessesTestBarrier.test_default_timeout'),

('test_multiprocessing_spawn.txt', '*graalpython.lib-python.3.test.test_multiprocessing_spawn.WithProcessesTestBarrier.test_timeout'),

('test_pty.txt', '*graalpython.lib-python.3.test.test_pty.PtyTest.test_openpty'),

# Disabled due to transient stack overflow that fails to get caught and crashes the VM

('test_exceptions.txt', '*graalpython.lib-python.3.test.test_exceptions.ExceptionTests.test_badisinstance'),

('test_exceptions.txt', '*graalpython.lib-python.3.test.test_exceptions.ExceptionTests.testInfiniteRecursion'),

('test_list.txt', '*graalpython.lib-python.3.test.test_list.ListTest.test_repr_deep'),

('test_functools.txt', '*graalpython.lib-python.3.test.test_functools.TestPartialC.test_recursive_pickle'),

('test_functools.txt', '*graalpython.lib-python.3.test.test_functools.TestPartialCSubclass.test_recursive_pickle'),

('test_functools.txt', '*graalpython.lib-python.3.test.test_functools.TestPartialPy.test_recursive_pickle'),

('test_functools.txt', '*graalpython.lib-python.3.test.test_functools.TestPartialPySubclass.test_recursive_pickle'),

# Transient, GR-41056

('test_subprocess.txt', '*graalpython.lib-python.3.test.test_subprocess.POSIXProcessTestCase.test_swap_std_fds_with_one_closed')

}

result_tags = linux_tags & darwin_tags - tag_exclusions

if not parsed_args.untag:

result_tags |= current_tags

_write_tags(result_tags)

diff = linux_tags - darwin_tags

if diff:

mx.warn("The following tests work only on Linux:\n" + '\n'.join(x[1] for x in diff))

diff = darwin_tags - linux_tags

if diff:

mx.warn("The following tests work only on Darwin:\n" + '\n'.join(x[1] for x in diff))

diff = current_tags - result_tags

if diff:

mx.warn("Potential regressions:\n" + '\n'.join(x[1] for x in diff))

AOT_INCOMPATIBLE_TESTS = ["test_interop.py", "test_jarray.py", "test_ssl_java_integration.py"]

# These test would work on JVM too, but they are prohibitively slow due to a large amount of subprocesses

AOT_ONLY_TESTS = ["test_patched_pip.py"]

GINSTALL_GATE_PACKAGES = {

"numpy": "numpy",

"scipy": "scipy",

"scikit_learn": "sklearn",

}

class GraalPythonTags(object):

junit = 'python-junit'

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_hpy = 'python-unittest-hpy'

unittest_hpy_sandboxed = 'python-unittest-hpy-sandboxed'

unittest_posix = 'python-unittest-posix'

ginstall = 'python-ginstall'

tagged = 'python-tagged-unittest'

tagged_sandboxed = 'python-tagged-unittest-sandboxed'

svmunit = 'python-svm-unittest'

svmunit_sandboxed = 'python-svm-unittest-sandboxed'

shared_object = 'python-so'

shared_object_sandboxed = 'python-so-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'

windows = 'python-windows-smoketests'

language_checker = 'python-language-checker'

exclusions_checker = 'python-class-exclusion-checker'

def python_gate(args):

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"]

include_sandboxed = mx.suite("sulong-managed", fatalIfMissing=False) is not None

for x in dir(GraalPythonTags):

v = getattr(GraalPythonTags, x)

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

if include_sandboxed and "sandboxed" in v:

tags.append(v)

elif not include_sandboxed and "sandboxed" not in v:

tags.append(v)

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

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

return mx.command_function("gate")(args)

python_gate.__doc__ = 'Custom gates are %s' % ", ".join([

getattr(GraalPythonTags, t) for t in dir(GraalPythonTags) if not t.startswith("__")

])

def find_eclipse():

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, "eclipse")

if os.path.exists(eclipse_exe):

os.environ["ECLIPSE_EXE"] = eclipse_exe

return

@contextlib.contextmanager

def set_env(**environ):

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

old_environ = dict(os.environ)

os.environ.update(environ)

try:

yield

finally:

os.environ.clear()

os.environ.update(old_environ)

def _graalvm_home(*, envfile, extra_dy=""):

if not os.path.isabs(envfile):

envfile = _sibling(envfile)

home = os.environ.get("GRAALVM_HOME", None)

if not home:

dy = ",".join(["%s%s" % ("/" if dy[1] else "", dy[0]) for dy in mx.get_dynamic_imports()])

dy += extra_dy

mx_args = ["--env", envfile]

if dy:

mx_args = ["--dy", dy] + mx_args

if mx._opts.verbose:

mx.run_mx(mx_args + ["graalvm-show"])

mx.run_mx(mx_args + ["build"])

out = mx.OutputCapture()

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

home = out.data.splitlines()[-1].strip()

elif "*" in home:

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

mx.log("choosing GRAALVM_HOME=%s" % home)

return home

def _join_bin(home, name):

if sys.platform == "darwin" and not re.search("Contents/Home/?$", home):

return os.path.join(home, "Contents", "Home", "bin", name)

elif sys.platform == "win32":

return os.path.join(home, "bin", f"{name}.cmd")

else:

return os.path.join(home, "bin", name)

def python_gvm(_=None):

home = _graalvm_home(envfile="graalpython-bash-launcher")

launcher = _join_bin(home, "graalpy")

if mx_gate.get_jacoco_agent_args():

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

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

# jacoco agent is requested.

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 shlex.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))

bash_launcher = f'{original_launcher}.sh'

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

f.write("#!/bin/sh\n")

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

f.write(f'{original_launcher} --jvm {exe_arg} {agent_args} "$@"\n')

os.chmod(bash_launcher, 0o775)

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

return bash_launcher

mx.log(launcher)

return launcher

def python_managed_gvm(_=None):

home = _graalvm_home(envfile="graalpython-managed-bash-launcher")

launcher = _join_bin(home, "graalpy-managed")

mx.log(launcher)

return launcher

def python_enterprise_gvm(_=None):

home = _graalvm_home(envfile="graalpython-managed-bash-launcher")

launcher = _join_bin(home, "graalpy")

mx.log(launcher)

return launcher

def python_svm(_=None):

if mx_gate.get_jacoco_agent_args():

return python_gvm()

home = _graalvm_home(envfile="graalpython-launcher")

launcher = _join_bin(home, "graalpy")

mx.log(launcher)

return launcher

def python_managed_svm():

home = _graalvm_home(envfile="graalpython-managed-launcher")

launcher = _join_bin(home, "graalpy-managed")

mx.log(launcher)

return launcher

def native_image(args):

mx.run_mx([

"-p", os.path.join(mx.suite("truffle").dir, "..", "substratevm"),

"--dy", "graalpython",

"--native-images=",

"build",

])

mx.run_mx([

"-p", os.path.join(mx.suite("truffle").dir, "..", "substratevm"),

"--dy", "graalpython",

"--native-images=",

"native-image",

*args

])

def python_so():

return _graalvm_home(envfile="graalpython-libpolyglot")

def python_managed_so():

return _graalvm_home(envfile="graalpython-managed-libpolyglot")

def _graalpytest_driver():

return os.path.join(SUITE.dir, "graalpython", "com.oracle.graal.python.test", "src", "graalpytest.py")

def _graalpytest_root():

return os.path.join(mx.dependency("com.oracle.graal.python.test").get_output_root(), "bin", "tests")

def _hpy_test_root():

return os.path.join(_get_core_home(), "modules", "hpy", "test")

def graalpytest(args):

parser = ArgumentParser(prog='mx graalpytest')

parser.add_argument('--python', type=str, action='store', default="", help='Run tests with custom Python binary.')

parser.add_argument('-v', "--verbose", action="store_true", help='Verbose output.', default=True)

parser.add_argument('-k', dest="filter", default='', help='Test pattern.')

parser.add_argument('test', nargs="*", default=[], help='Test file to run (specify absolute or relative; e.g. "/path/to/test_file.py" or "cpyext/test_object.py") ')

args, unknown_args = parser.parse_known_args(args)

# ensure that the test distribution is up-to-date

if not DISABLE_REBUILD:

mx.command_function("build")(["--dep", "com.oracle.graal.python.test"])

testfiles = _list_graalpython_unittests(args.test)

cmd_args = []

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

if not args.python:

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

# we assume that unknown args are polyglot arguments and just prepend them to the test driver

cmd_args += unknown_args + [_graalpytest_driver()]

if args.verbose:

cmd_args += ["-v"]

cmd_args += testfiles

if args.filter:

cmd_args += ["-k", args.filter]

env = os.environ.copy()

env['PYTHONHASHSEED'] = '0'

delete_bad_env_keys(env)

if args.python:

return mx.run([args.python] + cmd_args, nonZeroIsFatal=True, env=env)

else:

return do_run_python(cmd_args, env=env)

def _list_graalpython_unittests(paths=None, exclude=None):

exclude = [] if exclude is None else exclude

paths = paths or [_graalpytest_root()]

def is_included(path):

if path.endswith(".py"):

basename = os.path.basename(path)

return basename.startswith("test_") and basename not 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(_graalpytest_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)

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

if is_included(testfile):

testfiles.append(testfile)

return testfiles

def run_python_unittests(python_binary, args=None, paths=None, aot_compatible=False, exclude=None, env=None,

use_pytest=False, cwd=None, lock=None, out=None, err=None, nonZeroIsFatal=True, javaAsserts=False, timeout=None, report=False):

if lock:

lock.acquire()

# ensure that the test distribution is up-to-date

if not DISABLE_REBUILD:

mx.command_function("build")(["--dep", "com.oracle.graal.python.test"])

args = args or []

args = ["--experimental-options=true",

"--python.EnableDebuggingBuiltins",

"--python.CatchAllExceptions=true"] + args

exclude = exclude or []

if env is None:

env = os.environ.copy()

env['PYTHONHASHSEED'] = '0'

delete_bad_env_keys(env)

# list of excluded tests

if aot_compatible:

exclude += AOT_INCOMPATIBLE_TESTS

else:

exclude += AOT_ONLY_TESTS

# just to be able to verify, print C ext mode (also works for CPython)

mx.run([python_binary,

"-c",

"import sys; print('C EXT MODE: ' + (__graalpython__.platform_id if sys.implementation.name == 'graalpy' else 'cpython'))"],

nonZeroIsFatal=True, env=env, out=out, err=err)

# list all 1st-level tests and exclude the SVM-incompatible ones

testfiles = _list_graalpython_unittests(paths, exclude)

if use_pytest:

args += ["-m", "pytest", "-v", "--assert=plain", "--tb=native"]

else:

args += [_graalpytest_driver(), "-v"]

if report:

reportfile = None

t0 = time.time()

if not use_pytest:

reportfile = os.path.abspath(tempfile.mktemp(prefix="test-report-", suffix=".json"))

args += ["--report", reportfile]

result = 0

if is_collectiong_coverage():

env['ENABLE_THREADED_GRAALPYTEST'] = "false"

if mx_gate.get_jacoco_agent_args():

with open(python_binary, "r") as f:

assert f.read(9) == "#!/bin/sh"

# jacoco only dumps the data on exit, and when we run all our unittests

# at once it generates so much data we run out of heap space

for testfile in testfiles:

mx.run([python_binary] + args + [testfile], nonZeroIsFatal=nonZeroIsFatal, env=env, cwd=cwd, out=out, err=err, timeout=timeout)

else:

if javaAsserts:

args += ['-ea']

args += testfiles

mx.logv(" ".join([python_binary] + args))

if lock:

lock.release()

result = mx.run([python_binary] + args, nonZeroIsFatal=nonZeroIsFatal, env=env, cwd=cwd, out=out, err=err, timeout=timeout)

if report:

if reportfile:

mx_gate.make_test_report(reportfile, report.title)

else:

mx_gate.make_test_report([{

"name": report.title,

"status": "PASSED" if result == 0 else "FAILED",

"duration": int((time.time() - t0) * 1000)

}], report.title)

return result

def get_venv_env(env_dir):

env = os.environ.copy()

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

env.update(**{

'VIRTUAL_ENV': env_dir,

'PATH': ":".join([os.path.join(env_dir, 'bin'), path]),

})

if 'PYTHONHOME' in env:

del env['PYTHONHOME']

return env

def prepare_graalpy_venv(python_binary, packages=None, env_path=None, args=None):

if args is None:

args = []

if packages is None:

packages = []

if isinstance(packages, dict):

packages = list(packages.keys())

assert isinstance(packages, (tuple, set, list)), "packages arg must be a tuple, set or list"

env_dir = os.path.realpath(env_path if env_path else tempfile.mkdtemp())

mx.log("using graalpython venv: {}".format(env_dir))

mx.run([python_binary, "-m", "venv", env_dir], nonZeroIsFatal=True)

mx.log("installing the following packages: {}".format(", ".join(packages)))

for p in packages:

mx.run(["graalpy", "-m", "ginstall"] + args + ["install", p], nonZeroIsFatal=True, env=get_venv_env(env_dir))

return env_dir

def run_with_venv(cmd, env_dir, **kwargs):

assert isinstance(cmd, list), "cmd argument must be a list"

kwargs['env'] = get_venv_env(env_dir)

mx.run(cmd, **kwargs)

def run_ginstall(python_binary, args=None):

if args is None:

args = []

env_dir = prepare_graalpy_venv(python_binary, packages=GINSTALL_GATE_PACKAGES, args=args)

import_packages = '"{}"'.format(';'.join(["import {}".format(n) for p, n in GINSTALL_GATE_PACKAGES.items()]))

run_with_venv(["graalpy", "-c", import_packages], env_dir, nonZeroIsFatal=True)

def is_bash_launcher(launcher_path):

with open(launcher_path, 'r', encoding='ascii', errors='ignore') as launcher:

return re.match(r'^#!.*bash', launcher.readline())

def patch_batch_launcher(launcher_path, jvm_args):

with open(launcher_path, 'r', encoding='ascii', errors='ignore') as launcher:

lines = launcher.readlines()

assert re.match(r'^#!.*bash', lines[0]), "expected a bash launcher"

lines.insert(-1, 'jvm_args+=(%s)\n' % jvm_args)

with open(launcher_path, 'w') as launcher:

launcher.writelines(lines)

def run_hpy_unittests(python_binary, args=None, include_native=True, env=None, nonZeroIsFatal=True, timeout=None, report=False):