loader_details = (machinery.SourceFileLoader, machinery.SOURCE_SUFFIXES)

spec = machinery.FileFinder(path, loader_details).find_spec(name)

module = util.module_from_spec(spec)

spec.loader.exec_module(module)

file = None

try:

(file, pathname, description) = imp.find_module(name, [path])

return imp.load_module(name, file, pathname, description)

finally:

if file:

def __init__(self, cases, flaky_tests_mode, measure_flakiness):

self.cases = cases

self.serial_id = 0

self.flaky_tests_mode = flaky_tests_mode

self.measure_flakiness = measure_flakiness

self.parallel_queue = Queue(len(cases))

self.sequential_queue = Queue(len(cases))

for case in cases:

if case.parallel:

self.parallel_queue.put_nowait(case)

else:

self.sequential_queue.put_nowait(case)

self.succeeded = 0

self.remaining = len(cases)

self.total = len(cases)

self.failed = [ ]

self.flaky_failed = [ ]

self.crashed = 0

self.lock = threading.Lock()

self.shutdown_event = threading.Event()

def GetFailureOutput(self, failure):

output = []

if failure.output.stderr:

output += ["--- stderr ---" ]

output += [failure.output.stderr.strip()]

if failure.output.stdout:

output += ["--- stdout ---"]

output += [failure.output.stdout.strip()]

output += ["Command: %s" % failure.test.GetFailureCommand(failure.command)]

if failure.HasCrashed():

output += ["--- %s ---" % PrintCrashed(failure.output.exit_code)]

if failure.HasTimedOut():

output += ["--- TIMEOUT ---"]

output = "\n".join(output)

return output

def PrintFailureOutput(self, failure):

print(self.GetFailureOutput(failure))

def PrintFailureHeader(self, test):

if test.IsNegative():

negative_marker = '[negative] '

else:

negative_marker = ''

print("=== %(label)s %(negative)s===" % {

'label': test.GetLabel(),

'negative': negative_marker

})

print("Path: %s" % "/".join(test.path))

def Run(self, tasks) -> Dict:

self.Starting()

threads = []

# Spawn N-1 threads and then use this thread as the last one.

# That way -j1 avoids threading altogether which is a nice fallback

# in case of threading problems.

for i in range(tasks - 1):

thread = threading.Thread(target=self.RunSingle, args=[True, i + 1])

threads.append(thread)

thread.start()

try:

self.RunSingle(False, 0)

# Wait for the remaining threads

for thread in threads:

# Use a timeout so that signals (ctrl-c) will be processed.

thread.join(timeout=1000000)

except (KeyboardInterrupt, SystemExit):

self.shutdown_event.set()

except Exception:

# If there's an exception we schedule an interruption for any

# remaining threads.

self.shutdown_event.set()

# ...and then reraise the exception to bail out

raise

self.Done()

return {

'allPassed': not self.failed and not self.shutdown_event.is_set(),

'failed': self.failed,

}

def RunSingle(self, parallel, thread_id):

while not self.shutdown_event.is_set():

try:

test = self.parallel_queue.get_nowait()

except Empty:

if parallel:

return

try:

test = self.sequential_queue.get_nowait()

except Empty:

return

case = test

case.thread_id = thread_id

self.lock.acquire()

case.serial_id = self.serial_id

self.serial_id += 1

self.AboutToRun(case)

self.lock.release()

try:

start = datetime.now()

output = case.Run()

# SmartOS has a bug that causes unexpected ECONNREFUSED errors.

# See https://smartos.org/bugview/OS-2767

# If ECONNREFUSED on SmartOS, retry the test one time.

if (output.UnexpectedOutput() and

sys.platform == 'sunos5' and

'ECONNREFUSED' in output.output.stderr):

output = case.Run()

output.diagnostic.append('ECONNREFUSED received, test retried')

case.duration = (datetime.now() - start)

except IOError:

return

if self.shutdown_event.is_set():

return

self.lock.acquire()

if output.UnexpectedOutput():

if FLAKY in output.test.outcomes and self.flaky_tests_mode == DONTCARE:

self.flaky_failed.append(output)

elif FLAKY in output.test.outcomes and self.flaky_tests_mode == KEEP_RETRYING:

for _ in range(99):

if not case.Run().UnexpectedOutput():

self.flaky_failed.append(output)

break

else:

# If after 100 tries, the test is not passing, it's not flaky.

self.failed.append(output)

else:

self.failed.append(output)

if output.HasCrashed():

self.crashed += 1

if self.measure_flakiness:

outputs = [case.Run() for _ in range(self.measure_flakiness)]

# +1s are there because the test already failed once at this point.

print(" failed %d out of %d" % (len([i for i in outputs if i.UnexpectedOutput()]) + 1, self.measure_flakiness + 1))

else:

self.succeeded += 1

self.remaining -= 1

self.HasRun(output)

parts = []

for part in command:

if ' ' in part:

# Escape spaces. We may need to escape more characters for this

# to work properly.

parts.append('"%s"' % part)

else:

parts.append(part)

def Starting(self):

print('Running %i tests' % len(self.cases))

def Done(self):

print()

for failed in self.failed:

self.PrintFailureHeader(failed.test)

self.PrintFailureOutput(failed)

if len(self.failed) == 0:

print("===")

print("=== All tests succeeded")

print("===")

else:

print()

print("===")

print("=== %i tests failed" % len(self.failed))

if self.crashed > 0:

print("=== %i tests CRASHED" % self.crashed)

def AboutToRun(self, case):

print('Starting %s...' % case.GetLabel())

sys.stdout.flush()

def HasRun(self, output):

if output.UnexpectedOutput():

if output.HasCrashed():

outcome = 'CRASH'

else:

outcome = 'FAIL'

else:

outcome = 'pass'

def AboutToRun(self, case):

pass

def HasRun(self, output):

total = self.succeeded + len(self.failed)

if (total > 1) and (total % 50 == 1):

sys.stdout.write('\n')

if output.UnexpectedOutput():

if output.HasCrashed():

sys.stdout.write('C')

sys.stdout.flush()

elif output.HasTimedOut():

sys.stdout.write('T')

sys.stdout.flush()

else:

sys.stdout.write('F')

sys.stdout.flush()

else:

sys.stdout.write('.')

def AboutToRun(self, case):

pass

def GetAnnotationInfo(self, test, output):

traceback = output.stdout + output.stderr

find_full_path = re.search(r' +at .*\(.*%s:([0-9]+):([0-9]+)' % test.file, traceback)

col = line = 0

if find_full_path:

line, col = map(int, find_full_path.groups())

root_path = abspath(join(dirname(__file__), '../')) + os.sep

filename = test.file.replace(root_path, "")

return filename, line, col

def PrintFailureOutput(self, failure):

output = self.GetFailureOutput(failure)

filename, line, column = self.GetAnnotationInfo(failure.test, failure.output)

def _printDiagnostic(self):

logger.info(' severity: %s', self.severity)

self.exitcode and logger.info(' exitcode: %s', self.exitcode)

logger.info(' stack: |-')

for l in self.traceback.splitlines():

logger.info(' ' + l)

def Starting(self):

logger.info('TAP version 13')

logger.info('1..%i' % len(self.cases))

self._done = 0

def AboutToRun(self, case):

pass

def HasRun(self, output):

self._done += 1

self.traceback = ''

self.severity = 'ok'

self.exitcode = ''

# Print test name as (for example) "parallel/test-assert". Tests that are

# scraped from the addons documentation are all named test.js, making it

# hard to decipher what test is running when only the filename is printed.

command = output.test.GetReportingName(output.command)

if output.UnexpectedOutput():

status_line = 'not ok %i %s' % (self._done, command)

self.severity = 'fail'

self.exitcode = output.output.exit_code

self.traceback = output.output.stdout + output.output.stderr

if FLAKY in output.test.outcomes and self.flaky_tests_mode == DONTCARE:

status_line = status_line + ' # TODO : Fix flaky test'

self.severity = 'flaky'

logger.info(status_line)

if output.HasCrashed():

self.severity = 'crashed'

elif output.HasTimedOut():

self.severity = 'fail'

else:

skip = skip_regex.search(output.output.stdout)

if skip:

logger.info(

'ok %i %s # skip %s' % (self._done, command, skip.group(1)))

else:

status_line = 'ok %i %s' % (self._done, command)

if FLAKY in output.test.outcomes:

status_line = status_line + ' # TODO : Fix flaky test'

logger.info(status_line)

if output.diagnostic:

self.severity = 'ok'

if isinstance(output.diagnostic, list):

self.traceback = '\n'.join(output.diagnostic)

else:

self.traceback = output.diagnostic

duration = output.test.duration

logger.info(' ---')

logger.info(' duration_ms: %.5f' % (duration / timedelta(milliseconds=1)))

if self.severity != 'ok' or self.traceback != '':

if output.HasTimedOut():

self.traceback = 'timeout\n' + output.output.stdout + output.output.stderr

self._printDiagnostic()

logger.info(' ...')

def Done(self):

def Starting(self):

pass

def AboutToRun(self, case):

pass

def HasRun(self, output):

# Print test name as (for example) "parallel/test-assert". Tests that are

# scraped from the addons documentation are all named test.js, making it

# hard to decipher what test is running when only the filename is printed.

command = output.test.GetReportingName(output.command)

stdout = output.output.stdout.strip()

printed_file = False

for line in stdout.splitlines():

if (

(line.startswith("[aborted optimiz") or line.startswith("[disabled optimiz")) and

("because:" in line or "reason:" in line)

):

if not printed_file:

printed_file = True

print('==== %s ====' % command)

self.failed.append(output)

print(' %s' % line)

def Done(self):

def __init__(self, cases, flaky_tests_mode, measure_flakiness, templates):

super(CompactProgressIndicator, self).__init__(cases, flaky_tests_mode, measure_flakiness)

self.templates = templates

self.last_status_length = 0

self.start_time = time.time()

def Starting(self):

pass

def Done(self):

self.PrintProgress('Done\n')

def AboutToRun(self, case):

self.PrintProgress(case.GetLabel())

def HasRun(self, output):

if output.UnexpectedOutput():

self.ClearLine(self.last_status_length)

self.PrintFailureHeader(output.test)

stdout = output.output.stdout.strip()

if len(stdout):

print(self.templates['stdout'] % stdout)

stderr = output.output.stderr.strip()

if len(stderr):

print(self.templates['stderr'] % stderr)

print("Command: %s" % output.test.GetFailureCommand(output.command))

if output.HasCrashed():

print("--- %s ---" % PrintCrashed(output.output.exit_code))

if output.HasTimedOut():

print("--- TIMEOUT ---")

print("\n") # Two blank lines between failures, for visual separation

def Truncate(self, str, length):

if length and (len(str) > (length - 3)):

return str[:(length-3)] + "..."

else:

return str

def PrintProgress(self, name):

self.ClearLine(self.last_status_length)

elapsed = time.time() - self.start_time

status = self.templates['status_line'] % {

'passed': self.succeeded,

'remaining': (((self.total - self.remaining) * 100) // self.total),

'failed': len(self.failed),

'test': name,

'mins': int(elapsed) / 60,

'secs': int(elapsed) % 60

}

status = self.Truncate(status, 78)

self.last_status_length = len(status)

print(status, end='')

def __init__(self, cases, flaky_tests_mode, measure_flakiness):

templates = {

'status_line': "[%(mins)02i:%(secs)02i|\033[34m%%%(remaining) 4d\033[0m|\033[32m+%(passed) 4d\033[0m|\033[31m-%(failed) 4d\033[0m]: %(test)s",

'stdout': "\033[1m%s\033[0m",

'stderr': "\033[31m%s\033[0m",

}

super(ColorProgressIndicator, self).__init__(cases, flaky_tests_mode, measure_flakiness, templates)

def ClearLine(self, last_line_length):

def __init__(self, cases, flaky_tests_mode, measure_flakiness):

templates = {

'status_line': "[%(mins)02i:%(secs)02i|%%%(remaining) 4d|+%(passed) 4d|-%(failed) 4d]: %(test)s",

'stdout': '%s',

'stderr': '%s',

'clear': lambda last_line_length: ("\r" + (" " * last_line_length) + "\r"),

'max_length': 78

}

super(MonochromeProgressIndicator, self).__init__(cases, flaky_tests_mode, measure_flakiness, templates)

def ClearLine(self, last_line_length):

'verbose': VerboseProgressIndicator,

'dots': DotsProgressIndicator,

'actions': ActionsAnnotationProgressIndicator,

'color': ColorProgressIndicator,

'tap': TapProgressIndicator,

'mono': MonochromeProgressIndicator,

'deopts': DeoptsCheckProgressIndicator

def __init__(self, exit_code, timed_out, stdout, stderr):

self.exit_code = exit_code

self.timed_out = timed_out

self.stdout = stdout

self.stderr = stderr

def __init__(self, context, path, arch, mode):

self.path = path

self.context = context

self.duration = None

self.arch = arch

self.mode = mode

self.parallel = False

self.disable_core_files = False

self.max_virtual_memory = None

self.serial_id = 0

self.thread_id = 0

def GetReportingName(self, command):

prefix = abspath(join(dirname(__file__), '../test')) + os.sep

return NormalizePath(command[-1], prefix)

def GetFailureCommand(self, command):

return EscapeCommand(command)

def IsNegative(self):

return self.context.expect_fail

def DidFail(self, output):

if output.failed is None:

output.failed = self.IsFailureOutput(output)

return output.failed

def IsFailureOutput(self, output):

return output.exit_code != 0

def GetSource(self):

return "(no source available)"

def RunCommand(self, command, env):

full_command = self.context.processor(command)

output = Execute(full_command,

self.context,

self.context.GetTimeout(self.mode, self.config.section),

env,

disable_core_files = self.disable_core_files,

max_virtual_memory = self.max_virtual_memory)

return TestOutput(self,

full_command,

output,

self.context.store_unexpected_output)

def Run(self):

try:

run_configuration = self.GetRunConfiguration()

command = run_configuration['command']

envs = {}

if 'envs' in run_configuration:

envs.update(run_configuration['envs'])

envs.update({

"TEST_SERIAL_ID": "%d" % self.serial_id,

"TEST_THREAD_ID": "%d" % self.thread_id,

"TEST_PARALLEL" : "%d" % self.parallel,

"GITHUB_STEP_SUMMARY": "",

})

result = self.RunCommand(

command,

envs

)

finally:

# Tests can leave the tty in non-blocking mode. If the test runner

# tries to print to stdout/stderr after that and the tty buffer is

# full, it'll die with a EAGAIN OSError. Ergo, put the tty back in

# blocking mode before proceeding.

if sys.platform != 'win32':

from fcntl import fcntl, F_GETFL, F_SETFL

from os import O_NONBLOCK

for fd in 0,1,2: fcntl(fd, F_SETFL, ~O_NONBLOCK & fcntl(fd, F_GETFL))

def __init__(self, test, command, output, store_unexpected_output):

self.test = test

self.command = command

self.output = output

self.store_unexpected_output = store_unexpected_output

self.diagnostic = []

def UnexpectedOutput(self):

if self.HasCrashed():

outcome = CRASH

elif self.HasTimedOut():

outcome = TIMEOUT

elif self.HasFailed():

outcome = FAIL

else:

outcome = PASS

return not outcome in self.test.outcomes

def HasCrashed(self):

if utils.IsWindows():

return 0x80000000 & self.output.exit_code and not (0x3FFFFF00 & self.output.exit_code)

else:

# Timed out tests will have exit_code -signal.SIGTERM.

if self.output.timed_out:

return False

return self.output.exit_code < 0

def HasTimedOut(self):

return self.output.timed_out

def HasFailed(self):

execution_failed = self.test.DidFail(self.output)

if self.test.IsNegative():

return not execution_failed

else:

if utils.IsWindows():

os.popen('taskkill /T /F /PID %d' % pid)

else:

prev_error_mode = SEM_INVALID_VALUE

try:

import ctypes

prev_error_mode = ctypes.windll.kernel32.SetErrorMode(mode)

except ImportError:

pass

signal_to_send = signal.SIGTERM

if context.abort_on_timeout:

# Using SIGABRT here allows the OS to generate a core dump that can be

# looked at post-mortem, which helps for investigating failures that are

# difficult to reproduce.

signal_to_send = signal.SIGABRT

if context.verbose: print("#", " ".join(args))

popen_args = args

prev_error_mode = SEM_INVALID_VALUE

if utils.IsWindows():

if context.suppress_dialogs:

# Try to change the error mode to avoid dialogs on fatal errors. Don't

# touch any existing error mode flags by merging the existing error mode.

# See http://blogs.msdn.com/oldnewthing/archive/2004/07/27/198410.aspx.

error_mode = SEM_NOGPFAULTERRORBOX

prev_error_mode = Win32SetErrorMode(error_mode)

Win32SetErrorMode(error_mode | prev_error_mode)

process = subprocess.Popen(

args = popen_args,

**rest

)

if utils.IsWindows() and context.suppress_dialogs and prev_error_mode != SEM_INVALID_VALUE:

Win32SetErrorMode(prev_error_mode)

# Compute the end time - if the process crosses this limit we

# consider it timed out.

if timeout is None: end_time = None

else: end_time = time.time() + timeout

timed_out = False

# Repeatedly check the exit code from the process in a

# loop and keep track of whether or not it times out.

exit_code = None

sleep_time = INITIAL_SLEEP_TIME

while exit_code is None:

if (not end_time is None) and (time.time() >= end_time):

# Kill the process and wait for it to exit.

KillTimedOutProcess(context, process.pid)

exit_code = process.wait()

timed_out = True

else:

exit_code = process.poll()

if exit_code is None:

time.sleep(sleep_time)

sleep_time = sleep_time * SLEEP_TIME_FACTOR

if sleep_time > MAX_SLEEP_TIME:

sleep_time = MAX_SLEEP_TIME

while True:

try:

os.unlink(name)

except OSError as e:

# On Windows unlink() fails if another process (typically a virus scanner

# or the indexing service) has the file open. Those processes keep a

# file open for a short time only, so yield and try again; it'll succeed.

if sys.platform == 'win32' and e.errno == errno.EACCES:

time.sleep(0)

continue

PrintError("os.unlink() " + str(e))

stdin=None, max_virtual_memory=None):

(fd_out, outname) = tempfile.mkstemp()

(fd_err, errname) = tempfile.mkstemp()

if env is None:

env = {}

env_copy = os.environ.copy()

# Remove NODE_PATH

if "NODE_PATH" in env_copy:

del env_copy["NODE_PATH"]

# Remove NODE_REPL_EXTERNAL_MODULE

if "NODE_REPL_EXTERNAL_MODULE" in env_copy:

del env_copy["NODE_REPL_EXTERNAL_MODULE"]

# Extend environment

for key, value in env.items():

env_copy[key] = value

# We append NODE_SKIP_FLAG_CHECK (ref: test/common/index.js)

# to avoid parsing the test files twice when looking for

# flags or environment variables defined via // Flags: and // Env:

env_copy["NODE_SKIP_FLAG_CHECK"] = "true"

preexec_fn = None

def disableCoreFiles():

import resource

resource.setrlimit(resource.RLIMIT_CORE, (0,0))

if disable_core_files and not utils.IsWindows():

preexec_fn = disableCoreFiles

if max_virtual_memory is not None and utils.GuessOS() == 'linux':

def setMaxVirtualMemory():

import resource

resource.setrlimit(resource.RLIMIT_CORE, (0,0))

resource.setrlimit(resource.RLIMIT_AS, (max_virtual_memory,max_virtual_memory + 1))

if preexec_fn is not None:

prev_preexec_fn = preexec_fn

def setResourceLimits():

setMaxVirtualMemory()

prev_preexec_fn()

preexec_fn = setResourceLimits

else:

preexec_fn = setMaxVirtualMemory

(_process, exit_code, timed_out) = RunProcess(

context,

timeout,

args = args,

stdin = stdin,

stdout = fd_out,

stderr = fd_err,

env = env_copy,

preexec_fn = preexec_fn

)

os.close(fd_out)

os.close(fd_err)

output = open(outname, encoding='utf8').read()

errors = open(errname, encoding='utf8').read()

CheckedUnlink(outname)

CheckedUnlink(errname)

if len(path) == 0:

return (None, [ ])

else:

def __init__(self, context, root, section):

self.context = context

self.root = root

self.section = section

def Contains(self, path, file):

if len(path) > len(file):

return False

for i in range(len(path)):

if not path[i].match(NormalizePath(file[i])):

return False

return True

def GetTestStatus(self, sections, defs):

status_file = join(self.root, '%s.status' % self.section)

if exists(status_file):

def __init__(self, name):

self.name = name

def GetName(self):

def __init__(self, path):

normalized_path = abspath(path)

super(TestRepository, self).__init__(basename(normalized_path))

self.path = normalized_path

self.is_loaded = False

self.config = None

def GetConfiguration(self, context):

if self.is_loaded:

return self.config

self.is_loaded = True

module = get_module('testcfg', self.path)

self.config = module.GetConfiguration(context, self.path)

if hasattr(self.config, 'additional_flags'):

self.config.additional_flags += context.node_args

else:

self.config.additional_flags = context.node_args

return self.config

def GetBuildRequirements(self, path, context):

return self.GetConfiguration(context).GetBuildRequirements()

def AddTestsToList(self, result, current_path, path, context, arch, mode):

tests = self.GetConfiguration(context).ListTests(current_path, path,

arch, mode)

result += tests

for i in range(1, context.repeat):

result += copy.deepcopy(tests)

def GetTestStatus(self, context, sections, defs):

def __init__(self, tests_repos, test_root):

super(LiteralTestSuite, self).__init__('root')

self.tests_repos = tests_repos

self.test_root = test_root

def GetBuildRequirements(self, path, context):

(name, rest) = CarCdr(path)

result = [ ]

for test in self.tests_repos:

if not name or name.match(test.GetName()):

result += test.GetBuildRequirements(rest, context)

return result

def ListTests(self, current_path, path, context, arch, mode):

(name, _rest) = CarCdr(path)

result = [ ]

for test in self.tests_repos:

test_name = test.GetName()

if not name or name.match(test_name):

full_path = current_path + [test_name]

test.AddTestsToList(result, full_path, path, context, arch, mode)

result.sort(key=lambda x: x.GetName())

return result

def GetTestStatus(self, context, sections, defs):

# Just read the test configuration from root_path/root.status.

root = TestConfiguration(context, self.test_root, 'root')

root.GetTestStatus(sections, defs)

for tests_repos in self.tests_repos:

'arm' : { 'debug' : 8, 'release' : 3 }, # The ARM buildbots are slow.

'riscv64' : { 'debug' : 8, 'release' : 3 }, # The riscv devices are slow.

'loong64' : { 'debug' : 4, 'release' : 1 },

'ia32' : { 'debug' : 4, 'release' : 1 },

'ppc' : { 'debug' : 4, 'release' : 1 },

def __init__(self, workspace, verbose, vm, args, expect_fail,

timeout, processor, suppress_dialogs,

store_unexpected_output, repeat, abort_on_timeout):

self.workspace = workspace

self.verbose = verbose

self.vm = vm

self.node_args = args

self.expect_fail = expect_fail

self.timeout = timeout

self.processor = processor

self.suppress_dialogs = suppress_dialogs

self.store_unexpected_output = store_unexpected_output

self.repeat = repeat

self.abort_on_timeout = abort_on_timeout

self.v8_enable_inspector = True

self.node_has_crypto = True

self.node_has_ffi = True

self.use_error_reporter = False

def GetVm(self, arch, mode):

if self.vm is not None:

return self.vm

if arch == 'none':

name = 'out/Debug/node' if mode == 'debug' else 'out/Release/node'

else:

name = 'out/%s.%s/node' % (arch, mode)

# Currently GYP does not support output_dir for MSVS.

# http://code.google.com/p/gyp/issues/detail?id=40

# It will put the builds into Release/node.exe or Debug/node.exe

if utils.IsWindows():

if not exists(name + '.exe'):

name = name.replace('out/', '')

name = os.path.abspath(name + '.exe')

if not exists(name):

raise ValueError('Could not find executable. Should be ' + name)

return name

def GetTimeout(self, mode, section=''):