#!/usr/bin/env python3

#

# Copyright 2008 the V8 project authors. All rights reserved.

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

# modification, are permitted provided that the following conditions are

# met:

#

# * Redistributions of source code must retain the above copyright

# notice, this list of conditions and the following disclaimer.

# * 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.

# * Neither the name of Google Inc. nor the names of its

# contributors may be used to endorse or promote products derived

# from this software without specific prior written permission.

#

# 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

# OWNER 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

from typing import Dict

import logging

import argparse

import os

import re

import signal

import subprocess

import sys

import tempfile

import time

import threading

import utils

import multiprocessing

import errno

import copy

import io

if sys.version_info >= (3, 5):

from importlib import machinery, util

def get_module(name, path):

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)

return module

else:

import imp

def get_module(name, path):

file = None

try:

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

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

finally:

if file:

file.close()

from io import open

from os.path import join, dirname, abspath, basename, isdir, exists

from datetime import datetime, timedelta

try:

from queue import Queue, Empty # Python 3

except ImportError:

from Queue import Queue, Empty # Python 2

from functools import reduce

try:

from urllib.parse import unquote # Python 3

except ImportError:

from urllib import unquote # Python 2

logger = logging.getLogger('testrunner')

skip_regex = re.compile(r'(?:\d+\.\.\d+|ok|not ok).*# SKIP\S*\s+(.*)', re.IGNORECASE)

VERBOSE = False

os.umask(0o022)

os.environ.pop('NODE_OPTIONS', None)

# ---------------------------------------------

# --- P r o g r e s s I n d i c a t o r s ---

# ---------------------------------------------

class ProgressIndicator(object):

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" % EscapeCommand(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)

self.lock.release()

def EscapeCommand(command):

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)

return " ".join(parts)

class SimpleProgressIndicator(ProgressIndicator):

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)

print("===")

class VerboseProgressIndicator(SimpleProgressIndicator):

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'

print('Done running %s: %s' % (output.test.GetLabel(), outcome))

class DotsProgressIndicator(SimpleProgressIndicator):

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('.')

sys.stdout.flush()

class ActionsAnnotationProgressIndicator(DotsProgressIndicator):

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)

print("::error file=%s,line=%d,col=%d::%s" % (filename, line, column, output.replace('\n', '%0A')))

class TapProgressIndicator(SimpleProgressIndicator):

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.

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

command = output.command[-1]

command = NormalizePath(command, prefix)

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

pass

class DeoptsCheckProgressIndicator(SimpleProgressIndicator):

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.

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

command = output.command[-1]

command = NormalizePath(command, prefix)

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

pass

class CompactProgressIndicator(ProgressIndicator):

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" % EscapeCommand(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='')

sys.stdout.flush()

class ColorProgressIndicator(CompactProgressIndicator):

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

print("\033[1K\r", end='')

class MonochromeProgressIndicator(CompactProgressIndicator):

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

print(("\r" + (" " * last_line_length) + "\r"), end='')

PROGRESS_INDICATORS = {

'verbose': VerboseProgressIndicator,

'dots': DotsProgressIndicator,

'actions': ActionsAnnotationProgressIndicator,

'color': ColorProgressIndicator,

'tap': TapProgressIndicator,

'mono': MonochromeProgressIndicator,

'deopts': DeoptsCheckProgressIndicator

}

# -------------------------

# --- F r a m e w o r k ---

# -------------------------

class CommandOutput(object):

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

self.failed = None

class TestCase(object):

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

return result

class TestOutput(object):

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:

return execution_failed

def KillProcessWithID(pid, signal_to_send=signal.SIGTERM):

if utils.IsWindows():

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

else:

os.kill(pid, signal_to_send)

MAX_SLEEP_TIME = 0.1

INITIAL_SLEEP_TIME = 0.0001

SLEEP_TIME_FACTOR = 1.25

SEM_INVALID_VALUE = -1

SEM_NOGPFAULTERRORBOX = 0x0002 # Microsoft Platform SDK WinBase.h

def Win32SetErrorMode(mode):

prev_error_mode = SEM_INVALID_VALUE

try:

import ctypes

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

except ImportError:

pass

return prev_error_mode

def KillTimedOutProcess(context, pid):

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

KillProcessWithID(pid, signal_to_send)

def RunProcess(context, timeout, args, **rest):

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

time.sleep(sleep_time)

sleep_time = sleep_time * SLEEP_TIME_FACTOR

if sleep_time > MAX_SLEEP_TIME:

sleep_time = MAX_SLEEP_TIME

return (process, exit_code, timed_out)

def PrintError(str):

sys.stderr.write(str)

sys.stderr.write('\n')

def CheckedUnlink(name):

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

break

def Execute(args, context, timeout=None, env=None, disable_core_files=False,

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)

return CommandOutput(exit_code, timed_out, output, errors)

def CarCdr(path):

if len(path) == 0:

return (None, [ ])

else:

return (path[0], path[1:])

class TestConfiguration(object):

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

ReadConfigurationInto(status_file, sections, defs)

class TestSuite(object):

def __init__(self, name):

self.name = name

def GetName(self):

return self.name

class TestRepository(TestSuite):

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

self.GetConfiguration(context).GetTestStatus(sections, defs)

class LiteralTestSuite(TestSuite):

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:

tests_repos.GetTestStatus(context, sections, defs)

TIMEOUT_SCALEFACTOR = {

'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 },

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

class Context(object):

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=''):

timeout = self.timeout * TIMEOUT_SCALEFACTOR[ARCH_GUESS or 'ia32'][mode]

if section == 'pummel' or section == 'benchmark':

timeout = timeout * 6

# We run all WPT from one subset in the same process using workers.