comparison core/scripts/run-tests.sh @ 0:4c8ae668cc8c

Initial import (non-working)

+<?php
+
+/**
+ * @file
+ * This script runs Drupal tests from command line.
+ */
+
+use Drupal\Component\FileSystem\FileSystem;
+use Drupal\Component\Utility\Html;
+use Drupal\Component\Utility\Timer;
+use Drupal\Component\Uuid\Php;
+use Drupal\Core\Database\Database;
+use Drupal\Core\Site\Settings;
+use Drupal\Core\StreamWrapper\PublicStream;
+use Drupal\Core\Test\TestDatabase;
+use Drupal\Core\Test\TestRunnerKernel;
+use Drupal\simpletest\Form\SimpletestResultsForm;
+use Drupal\simpletest\TestBase;
+use Drupal\simpletest\TestDiscovery;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\HttpFoundation\Request;
+
+$autoloader = require_once __DIR__ . '/../../autoload.php';
+
+// Define some colors for display.
+// A nice calming green.
+const SIMPLETEST_SCRIPT_COLOR_PASS = 32;
+// An alerting Red.
+const SIMPLETEST_SCRIPT_COLOR_FAIL = 31;
+// An annoying brown.
+const SIMPLETEST_SCRIPT_COLOR_EXCEPTION = 33;
+
+// Restricting the chunk of queries prevents memory exhaustion.
+const SIMPLETEST_SCRIPT_SQLITE_VARIABLE_LIMIT = 350;
+
+const SIMPLETEST_SCRIPT_EXIT_SUCCESS = 0;
+const SIMPLETEST_SCRIPT_EXIT_FAILURE = 1;
+const SIMPLETEST_SCRIPT_EXIT_EXCEPTION = 2;
+
+if (!class_exists(TestCase::class)) {
+  echo "\nrun-tests.sh requires the PHPUnit testing framework. Please use 'composer install --dev' to ensure that it is present.\n\n";
+  exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+}
+
+// Set defaults and get overrides.
+list($args, $count) = simpletest_script_parse_args();
+
+if ($args['help'] || $count == 0) {
+  simpletest_script_help();
+  exit(($count == 0) ? SIMPLETEST_SCRIPT_EXIT_FAILURE : SIMPLETEST_SCRIPT_EXIT_SUCCESS);
+}
+
+simpletest_script_init();
+
+try {
+  $request = Request::createFromGlobals();
+  $kernel = TestRunnerKernel::createFromRequest($request, $autoloader);
+  $kernel->prepareLegacyRequest($request);
+}
+catch (Exception $e) {
+  echo (string) $e;
+  exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+}
+
+if ($args['execute-test']) {
+  simpletest_script_setup_database();
+  simpletest_script_run_one_test($args['test-id'], $args['execute-test']);
+  // Sub-process exited already; this is just for clarity.
+  exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS);
+}
+
+if ($args['list']) {
+  // Display all available tests.
+  echo "\nAvailable test groups & classes\n";
+  echo "-------------------------------\n\n";
+  try {
+    $groups = simpletest_test_get_all($args['module']);
+  }
+  catch (Exception $e) {
+    error_log((string) $e);
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+  foreach ($groups as $group => $tests) {
+    echo $group . "\n";
+    foreach ($tests as $class => $info) {
+      echo " - $class\n";
+    }
+  }
+  exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS);
+}
+
+// List-files and list-files-json provide a way for external tools such as the
+// testbot to prioritize running changed tests.
+// @see https://www.drupal.org/node/2569585
+if ($args['list-files'] || $args['list-files-json']) {
+  // List all files which could be run as tests.
+  $test_discovery = NULL;
+  try {
+    $test_discovery = \Drupal::service('test_discovery');
+  } catch (Exception $e) {
+    error_log((string) $e);
+    echo (string)$e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+  // TestDiscovery::findAllClassFiles() gives us a classmap similar to a
+  // Composer 'classmap' array.
+  $test_classes = $test_discovery->findAllClassFiles();
+  // JSON output is the easiest.
+  if ($args['list-files-json']) {
+    echo json_encode($test_classes);
+    exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS);
+  }
+  // Output the list of files.
+  else {
+    foreach(array_values($test_classes) as $test_class) {
+      echo $test_class . "\n";
+    }
+  }
+  exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS);
+}
+
+simpletest_script_setup_database(TRUE);
+
+if ($args['clean']) {
+  // Clean up left-over tables and directories.
+  try {
+    simpletest_clean_environment();
+  }
+  catch (Exception $e) {
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+  echo "\nEnvironment cleaned.\n";
+
+  // Get the status messages and print them.
+  $messages = drupal_get_messages('status');
+  foreach ($messages['status'] as $text) {
+    echo " - " . $text . "\n";
+  }
+  exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS);
+}
+
+$test_list = simpletest_script_get_test_list();
+
+// Try to allocate unlimited time to run the tests.
+drupal_set_time_limit(0);
+simpletest_script_reporter_init();
+
+$tests_to_run = array();
+for ($i = 0; $i < $args['repeat']; $i++) {
+  $tests_to_run = array_merge($tests_to_run, $test_list);
+}
+
+// Execute tests.
+$status = simpletest_script_execute_batch($tests_to_run);
+
+// Stop the timer.
+simpletest_script_reporter_timer_stop();
+
+// Ensure all test locks are released once finished. If tests are run with a
+// concurrency of 1 the each test will clean up its own lock. Test locks are
+// not released if using a higher concurrency to ensure each test method has
+// unique fixtures.
+TestDatabase::releaseAllTestLocks();
+
+// Display results before database is cleared.
+if ($args['browser']) {
+  simpletest_script_open_browser();
+}
+else {
+  simpletest_script_reporter_display_results();
+}
+
+if ($args['xml']) {
+  simpletest_script_reporter_write_xml_results();
+}
+
+// Clean up all test results.
+if (!$args['keep-results']) {
+  try {
+    simpletest_clean_results_table();
+  }
+  catch (Exception $e) {
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+}
+
+// Test complete, exit.
+exit($status);
+
+/**
+ * Print help text.
+ */
+function simpletest_script_help() {
+  global $args;
+
+  echo <<<EOF
+
+Run Drupal tests from the shell.
+
+Usage:        {$args['script']} [OPTIONS] <tests>
+Example:      {$args['script']} Profile
+
+All arguments are long options.
+
+  --help      Print this page.
+
+  --list      Display all available test groups.
+
+  --list-files
+              Display all discoverable test file paths.
+
+  --list-files-json
+              Display all discoverable test files as JSON. The array key will be
+              the test class name, and the value will be the file path of the
+              test.
+
+  --clean     Cleans up database tables or directories from previous, failed,
+              tests and then exits (no tests are run).
+
+  --url       The base URL of the root directory of this Drupal checkout; e.g.:
+                http://drupal.test/
+              Required unless the Drupal root directory maps exactly to:
+                http://localhost:80/
+              Use a https:// URL to force all tests to be run under SSL.
+
+  --sqlite    A pathname to use for the SQLite database of the test runner.
+              Required unless this script is executed with a working Drupal
+              installation that has Simpletest module installed.
+              A relative pathname is interpreted relative to the Drupal root
+              directory.
+              Note that ':memory:' cannot be used, because this script spawns
+              sub-processes. However, you may use e.g. '/tmpfs/test.sqlite'
+
+  --keep-results-table
+
+              Boolean flag to indicate to not cleanup the simpletest result
+              table. For testbots or repeated execution of a single test it can
+              be helpful to not cleanup the simpletest result table.
+
+  --dburl     A URI denoting the database driver, credentials, server hostname,
+              and database name to use in tests.
+              Required when running tests without a Drupal installation that
+              contains default database connection info in settings.php.
+              Examples:
+                mysql://username:password@localhost/databasename#table_prefix
+                sqlite://localhost/relative/path/db.sqlite
+                sqlite://localhost//absolute/path/db.sqlite
+
+  --php       The absolute path to the PHP executable. Usually not needed.
+
+  --concurrency [num]
+
+              Run tests in parallel, up to [num] tests at a time.
+
+  --all       Run all available tests.
+
+  --module    Run all tests belonging to the specified module name.
+              (e.g., 'node')
+
+  --class     Run tests identified by specific class names, instead of group names.
+              A specific test method can be added, for example,
+              'Drupal\book\Tests\BookTest::testBookExport'.
+
+  --file      Run tests identified by specific file names, instead of group names.
+              Specify the path and the extension
+              (i.e. 'core/modules/user/user.test').
+
+  --types
+
+              Runs just tests from the specified test type, for example
+              run-tests.sh
+              (i.e. --types "Simpletest,PHPUnit-Functional")
+
+  --directory Run all tests found within the specified file directory.
+
+  --xml       <path>
+
+              If provided, test results will be written as xml files to this path.
+
+  --color     Output text format results with color highlighting.
+
+  --verbose   Output detailed assertion messages in addition to summary.
+
+  --keep-results
+
+              Keeps detailed assertion results (in the database) after tests
+              have completed. By default, assertion results are cleared.
+
+  --repeat    Number of times to repeat the test.
+
+  --die-on-fail
+
+              Exit test execution immediately upon any failed assertion. This
+              allows to access the test site by changing settings.php to use the
+              test database and configuration directories. Use in combination
+              with --repeat for debugging random test failures.
+
+  --browser   Opens the results in the browser. This enforces --keep-results and
+              if you want to also view any pages rendered in the simpletest
+              browser you need to add --verbose to the command line.
+
+  --non-html  Removes escaping from output. Useful for reading results on the
+              CLI.
+
+  <test1>[,<test2>[,<test3> ...]]
+
+              One or more tests to be run. By default, these are interpreted
+              as the names of test groups as shown at
+              admin/config/development/testing.
+              These group names typically correspond to module names like "User"
+              or "Profile" or "System", but there is also a group "Database".
+              If --class is specified then these are interpreted as the names of
+              specific test classes whose test methods will be run. Tests must
+              be separated by commas. Ignored if --all is specified.
+
+To run this script you will normally invoke it from the root directory of your
+Drupal installation as the webserver user (differs per configuration), or root:
+
+sudo -u [wwwrun|www-data|etc] php ./core/scripts/{$args['script']}
+  --url http://example.com/ --all
+sudo -u [wwwrun|www-data|etc] php ./core/scripts/{$args['script']}
+  --url http://example.com/ --class "Drupal\block\Tests\BlockTest"
+
+Without a preinstalled Drupal site and enabled Simpletest module, specify a
+SQLite database pathname to create and the default database connection info to
+use in tests:
+
+sudo -u [wwwrun|www-data|etc] php ./core/scripts/{$args['script']}
+  --sqlite /tmpfs/drupal/test.sqlite
+  --dburl mysql://username:password@localhost/database
+  --url http://example.com/ --all
+
+EOF;
+}
+
+/**
+ * Parse execution argument and ensure that all are valid.
+ *
+ * @return array
+ *   The list of arguments.
+ */
+function simpletest_script_parse_args() {
+  // Set default values.
+  $args = array(
+    'script' => '',
+    'help' => FALSE,
+    'list' => FALSE,
+    'list-files' => FALSE,
+    'list-files-json' => FALSE,
+    'clean' => FALSE,
+    'url' => '',
+    'sqlite' => NULL,
+    'dburl' => NULL,
+    'php' => '',
+    'concurrency' => 1,
+    'all' => FALSE,
+    'module' => NULL,
+    'class' => FALSE,
+    'file' => FALSE,
+    'types' => [],
+    'directory' => NULL,
+    'color' => FALSE,
+    'verbose' => FALSE,
+    'keep-results' => FALSE,
+    'keep-results-table' => FALSE,
+    'test_names' => array(),
+    'repeat' => 1,
+    'die-on-fail' => FALSE,
+    'browser' => FALSE,
+    // Used internally.
+    'test-id' => 0,
+    'execute-test' => '',
+    'xml' => '',
+    'non-html' => FALSE,
+  );
+
+  // Override with set values.
+  $args['script'] = basename(array_shift($_SERVER['argv']));
+
+  $count = 0;
+  while ($arg = array_shift($_SERVER['argv'])) {
+    if (preg_match('/--(\S+)/', $arg, $matches)) {
+      // Argument found.
+      if (array_key_exists($matches[1], $args)) {
+        // Argument found in list.
+        $previous_arg = $matches[1];
+        if (is_bool($args[$previous_arg])) {
+          $args[$matches[1]] = TRUE;
+        }
+        elseif (is_array($args[$previous_arg])) {
+          $value = array_shift($_SERVER['argv']);
+          $args[$matches[1]] = array_map('trim', explode(',', $value));
+        }
+        else {
+          $args[$matches[1]] = array_shift($_SERVER['argv']);
+        }
+        // Clear extraneous values.
+        $args['test_names'] = array();
+        $count++;
+      }
+      else {
+        // Argument not found in list.
+        simpletest_script_print_error("Unknown argument '$arg'.");
+        exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+      }
+    }
+    else {
+      // Values found without an argument should be test names.
+      $args['test_names'] += explode(',', $arg);
+      $count++;
+    }
+  }
+
+  // Validate the concurrency argument.
+  if (!is_numeric($args['concurrency']) || $args['concurrency'] <= 0) {
+    simpletest_script_print_error("--concurrency must be a strictly positive integer.");
+    exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+  }
+
+  if ($args['browser']) {
+    $args['keep-results'] = TRUE;
+  }
+  return array($args, $count);
+}
+
+/**
+ * Initialize script variables and perform general setup requirements.
+ */
+function simpletest_script_init() {
+  global $args, $php;
+
+  $host = 'localhost';
+  $path = '';
+  $port = '80';
+
+  // Determine location of php command automatically, unless a command line
+  // argument is supplied.
+  if (!empty($args['php'])) {
+    $php = $args['php'];
+  }
+  elseif ($php_env = getenv('_')) {
+    // '_' is an environment variable set by the shell. It contains the command
+    // that was executed.
+    $php = $php_env;
+  }
+  elseif ($sudo = getenv('SUDO_COMMAND')) {
+    // 'SUDO_COMMAND' is an environment variable set by the sudo program.
+    // Extract only the PHP interpreter, not the rest of the command.
+    list($php) = explode(' ', $sudo, 2);
+  }
+  else {
+    simpletest_script_print_error('Unable to automatically determine the path to the PHP interpreter. Supply the --php command line argument.');
+    simpletest_script_help();
+    exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+  }
+
+  // Get URL from arguments.
+  if (!empty($args['url'])) {
+    $parsed_url = parse_url($args['url']);
+    $host = $parsed_url['host'] . (isset($parsed_url['port']) ? ':' . $parsed_url['port'] : '');
+    $path = isset($parsed_url['path']) ? rtrim(rtrim($parsed_url['path']), '/') : '';
+    $port = (isset($parsed_url['port']) ? $parsed_url['port'] : $port);
+    if ($path == '/') {
+      $path = '';
+    }
+    // If the passed URL schema is 'https' then setup the $_SERVER variables
+    // properly so that testing will run under HTTPS.
+    if ($parsed_url['scheme'] == 'https') {
+      $_SERVER['HTTPS'] = 'on';
+    }
+  }
+
+  if (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on') {
+    $base_url = 'https://';
+  }
+  else {
+    $base_url = 'http://';
+  }
+  $base_url .= $host;
+  if ($path !== '') {
+    $base_url .= $path;
+  }
+  putenv('SIMPLETEST_BASE_URL=' . $base_url);
+  $_SERVER['HTTP_HOST'] = $host;
+  $_SERVER['REMOTE_ADDR'] = '127.0.0.1';
+  $_SERVER['SERVER_ADDR'] = '127.0.0.1';
+  $_SERVER['SERVER_PORT'] = $port;
+  $_SERVER['SERVER_SOFTWARE'] = NULL;
+  $_SERVER['SERVER_NAME'] = 'localhost';
+  $_SERVER['REQUEST_URI'] = $path . '/';
+  $_SERVER['REQUEST_METHOD'] = 'GET';
+  $_SERVER['SCRIPT_NAME'] = $path . '/index.php';
+  $_SERVER['SCRIPT_FILENAME'] = $path . '/index.php';
+  $_SERVER['PHP_SELF'] = $path . '/index.php';
+  $_SERVER['HTTP_USER_AGENT'] = 'Drupal command line';
+
+  if ($args['concurrency'] > 1) {
+    $directory = FileSystem::getOsTemporaryDirectory();
+    $test_symlink = @symlink(__FILE__, $directory . '/test_symlink');
+    if (!$test_symlink) {
+      throw new \RuntimeException('In order to use a concurrency higher than 1 the test system needs to be able to create symlinks in ' . $directory);
+    }
+    unlink($directory . '/test_symlink');
+    putenv('RUN_TESTS_CONCURRENCY=' . $args['concurrency']);
+  }
+
+  if (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on') {
+    // Ensure that any and all environment variables are changed to https://.
+    foreach ($_SERVER as $key => $value) {
+      $_SERVER[$key] = str_replace('http://', 'https://', $_SERVER[$key]);
+    }
+  }
+
+  chdir(realpath(__DIR__ . '/../..'));
+}
+
+/**
+ * Sets up database connection info for running tests.
+ *
+ * If this script is executed from within a real Drupal installation, then this
+ * function essentially performs nothing (unless the --sqlite or --dburl
+ * parameters were passed).
+ *
+ * Otherwise, there are three database connections of concern:
+ * - --sqlite: The test runner connection, providing access to Simpletest
+ *   database tables for recording test IDs and assertion results.
+ * - --dburl: A database connection that is used as base connection info for all
+ *   tests; i.e., every test will spawn from this connection. In case this
+ *   connection uses e.g. SQLite, then all tests will run against SQLite. This
+ *   is exposed as $databases['default']['default'] to Drupal.
+ * - The actual database connection used within a test. This is the same as
+ *   --dburl, but uses an additional database table prefix. This is
+ *   $databases['default']['default'] within a test environment. The original
+ *   connection is retained in
+ *   $databases['simpletest_original_default']['default'] and restored after
+ *   each test.
+ *
+ * @param bool $new
+ *   Whether this process is a run-tests.sh master process. If TRUE, the SQLite
+ *   database file specified by --sqlite (if any) is set up. Otherwise, database
+ *   connections are prepared only.
+ */
+function simpletest_script_setup_database($new = FALSE) {
+  global $args;
+
+  // If there is an existing Drupal installation that contains a database
+  // connection info in settings.php, then $databases['default']['default'] will
+  // hold the default database connection already. This connection is assumed to
+  // be valid, and this connection will be used in tests, so that they run
+  // against e.g. MySQL instead of SQLite.
+  // However, in case no Drupal installation exists, this default database
+  // connection can be set and/or overridden with the --dburl parameter.
+  if (!empty($args['dburl'])) {
+    // Remove a possibly existing default connection (from settings.php).
+    Database::removeConnection('default');
+    try {
+      $databases['default']['default'] = Database::convertDbUrlToConnectionInfo($args['dburl'], DRUPAL_ROOT);
+    }
+    catch (\InvalidArgumentException $e) {
+      simpletest_script_print_error('Invalid --dburl. Reason: ' . $e->getMessage());
+      exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+    }
+  }
+  // Otherwise, use the default database connection from settings.php.
+  else {
+    $databases['default'] = Database::getConnectionInfo('default');
+  }
+
+  // If there is no default database connection for tests, we cannot continue.
+  if (!isset($databases['default']['default'])) {
+    simpletest_script_print_error('Missing default database connection for tests. Use --dburl to specify one.');
+    exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+  }
+  Database::addConnectionInfo('default', 'default', $databases['default']['default']);
+
+  // If no --sqlite parameter has been passed, then Simpletest module is assumed
+  // to be installed, so the test runner database connection is the default
+  // database connection.
+  if (empty($args['sqlite'])) {
+    $sqlite = FALSE;
+    $databases['test-runner']['default'] = $databases['default']['default'];
+  }
+  // Otherwise, set up a SQLite connection for the test runner.
+  else {
+    if ($args['sqlite'][0] === '/') {
+      $sqlite = $args['sqlite'];
+    }
+    else {
+      $sqlite = DRUPAL_ROOT . '/' . $args['sqlite'];
+    }
+    $databases['test-runner']['default'] = array(
+      'driver' => 'sqlite',
+      'database' => $sqlite,
+      'prefix' => array(
+        'default' => '',
+      ),
+    );
+    // Create the test runner SQLite database, unless it exists already.
+    if ($new && !file_exists($sqlite)) {
+      if (!is_dir(dirname($sqlite))) {
+        mkdir(dirname($sqlite));
+      }
+      touch($sqlite);
+    }
+  }
+
+  // Add the test runner database connection.
+  Database::addConnectionInfo('test-runner', 'default', $databases['test-runner']['default']);
+
+  // Create the Simpletest schema.
+  try {
+    $connection = Database::getConnection('default', 'test-runner');
+    $schema = $connection->schema();
+  }
+  catch (\PDOException $e) {
+    simpletest_script_print_error($databases['test-runner']['default']['driver'] . ': ' . $e->getMessage());
+    exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+  }
+  if ($new && $sqlite) {
+    require_once DRUPAL_ROOT . '/' . drupal_get_path('module', 'simpletest') . '/simpletest.install';
+    foreach (simpletest_schema() as $name => $table_spec) {
+      try {
+        $table_exists = $schema->tableExists($name);
+        if (empty($args['keep-results-table']) && $table_exists) {
+          $connection->truncate($name)->execute();
+        }
+        if (!$table_exists) {
+          $schema->createTable($name, $table_spec);
+        }
+      }
+      catch (Exception $e) {
+        echo (string) $e;
+        exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+      }
+    }
+  }
+  // Verify that the Simpletest database schema exists by checking one table.
+  try {
+    if (!$schema->tableExists('simpletest')) {
+      simpletest_script_print_error('Missing Simpletest database schema. Either install Simpletest module or use the --sqlite parameter.');
+      exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+    }
+  }
+  catch (Exception $e) {
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+}
+
+/**
+ * Execute a batch of tests.
+ */
+function simpletest_script_execute_batch($test_classes) {
+  global $args, $test_ids;
+
+  $total_status = SIMPLETEST_SCRIPT_EXIT_SUCCESS;
+
+  // Multi-process execution.
+  $children = array();
+  while (!empty($test_classes) || !empty($children)) {
+    while (count($children) < $args['concurrency']) {
+      if (empty($test_classes)) {
+        break;
+      }
+
+      try {
+        $test_id = Database::getConnection('default', 'test-runner')
+          ->insert('simpletest_test_id')
+          ->useDefaults(array('test_id'))
+          ->execute();
+      }
+      catch (Exception $e) {
+        echo (string) $e;
+        exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+      }
+      $test_ids[] = $test_id;
+
+      $test_class = array_shift($test_classes);
+      // Fork a child process.
+      $command = simpletest_script_command($test_id, $test_class);
+      $process = proc_open($command, array(), $pipes, NULL, NULL, array('bypass_shell' => TRUE));
+
+      if (!is_resource($process)) {
+        echo "Unable to fork test process. Aborting.\n";
+        exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS);
+      }
+
+      // Register our new child.
+      $children[] = array(
+        'process' => $process,
+        'test_id' => $test_id,
+        'class' => $test_class,
+        'pipes' => $pipes,
+      );
+    }
+
+    // Wait for children every 200ms.
+    usleep(200000);
+
+    // Check if some children finished.
+    foreach ($children as $cid => $child) {
+      $status = proc_get_status($child['process']);
+      if (empty($status['running'])) {
+        // The child exited, unregister it.
+        proc_close($child['process']);
+        if ($status['exitcode'] === SIMPLETEST_SCRIPT_EXIT_FAILURE) {
+          $total_status = max($status['exitcode'], $total_status);
+        }
+        elseif ($status['exitcode']) {
+          $message = 'FATAL ' . $child['class'] . ': test runner returned a non-zero error code (' . $status['exitcode'] . ').';
+          echo $message . "\n";
+          // @todo Return SIMPLETEST_SCRIPT_EXIT_EXCEPTION instead, when
+          // DrupalCI supports this.
+          // @see https://www.drupal.org/node/2780087
+          $total_status = max(SIMPLETEST_SCRIPT_EXIT_FAILURE, $total_status);
+          // Insert a fail for xml results.
+          TestBase::insertAssert($child['test_id'], $child['class'], FALSE, $message, 'run-tests.sh check');
+          // Ensure that an error line is displayed for the class.
+          simpletest_script_reporter_display_summary(
+            $child['class'],
+            ['#pass' => 0, '#fail' => 1, '#exception' => 0, '#debug' => 0]
+          );
+          if ($args['die-on-fail']) {
+            list($db_prefix) = simpletest_last_test_get($child['test_id']);
+            $test_db = new TestDatabase($db_prefix);
+            $test_directory = $test_db->getTestSitePath();
+            echo 'Simpletest database and files kept and test exited immediately on fail so should be reproducible if you change settings.php to use the database prefix ' . $db_prefix . ' and config directories in ' . $test_directory . "\n";
+            $args['keep-results'] = TRUE;
+            // Exit repeat loop immediately.
+            $args['repeat'] = -1;
+          }
+        }
+        // Free-up space by removing any potentially created resources.
+        if (!$args['keep-results']) {
+          simpletest_script_cleanup($child['test_id'], $child['class'], $status['exitcode']);
+        }
+
+        // Remove this child.
+        unset($children[$cid]);
+      }
+    }
+  }
+  return $total_status;
+}
+
+/**
+ * Run a PHPUnit-based test.
+ */
+function simpletest_script_run_phpunit($test_id, $class) {
+  $reflection = new \ReflectionClass($class);
+  if ($reflection->hasProperty('runLimit')) {
+    set_time_limit($reflection->getStaticPropertyValue('runLimit'));
+  }
+
+  $results = simpletest_run_phpunit_tests($test_id, array($class), $status);
+  simpletest_process_phpunit_results($results);
+
+  // Map phpunit results to a data structure we can pass to
+  // _simpletest_format_summary_line.
+  $summaries = simpletest_summarize_phpunit_result($results);
+  foreach ($summaries as $class => $summary) {
+    simpletest_script_reporter_display_summary($class, $summary);
+  }
+  return $status;
+}
+
+/**
+ * Run a single test, bootstrapping Drupal if needed.
+ */
+function simpletest_script_run_one_test($test_id, $test_class) {
+  global $args;
+
+  try {
+    if (strpos($test_class, '::') > 0) {
+      list($class_name, $method) = explode('::', $test_class, 2);
+      $methods = [$method];
+    }
+    else {
+      $class_name = $test_class;
+      // Use empty array to run all the test methods.
+      $methods = array();
+    }
+    $test = new $class_name($test_id);
+    if (is_subclass_of($test_class, TestCase::class)) {
+      $status = simpletest_script_run_phpunit($test_id, $test_class);
+    }
+    else {
+      $test->dieOnFail = (bool) $args['die-on-fail'];
+      $test->verbose = (bool) $args['verbose'];
+      $test->run($methods);
+      simpletest_script_reporter_display_summary($test_class, $test->results);
+
+      $status = SIMPLETEST_SCRIPT_EXIT_SUCCESS;
+      // Finished, kill this runner.
+      if ($test->results['#fail'] || $test->results['#exception']) {
+        $status = SIMPLETEST_SCRIPT_EXIT_FAILURE;
+      }
+    }
+
+    exit($status);
+  }
+  // DrupalTestCase::run() catches exceptions already, so this is only reached
+  // when an exception is thrown in the wrapping test runner environment.
+  catch (Exception $e) {
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+}
+
+/**
+ * Return a command used to run a test in a separate process.
+ *
+ * @param int $test_id
+ *   The current test ID.
+ * @param string $test_class
+ *   The name of the test class to run.
+ *
+ * @return string
+ *   The assembled command string.
+ */
+function simpletest_script_command($test_id, $test_class) {
+  global $args, $php;
+
+  $command = escapeshellarg($php) . ' ' . escapeshellarg('./core/scripts/' . $args['script']);
+  $command .= ' --url ' . escapeshellarg($args['url']);
+  if (!empty($args['sqlite'])) {
+    $command .= ' --sqlite ' . escapeshellarg($args['sqlite']);
+  }
+  if (!empty($args['dburl'])) {
+    $command .= ' --dburl ' . escapeshellarg($args['dburl']);
+  }
+  $command .= ' --php ' . escapeshellarg($php);
+  $command .= " --test-id $test_id";
+  foreach (array('verbose', 'keep-results', 'color', 'die-on-fail') as $arg) {
+    if ($args[$arg]) {
+      $command .= ' --' . $arg;
+    }
+  }
+  // --execute-test and class name needs to come last.
+  $command .= ' --execute-test ' . escapeshellarg($test_class);
+  return $command;
+}
+
+/**
+ * Removes all remnants of a test runner.
+ *
+ * In case a (e.g., fatal) error occurs after the test site has been fully setup
+ * and the error happens in many tests, the environment that executes the tests
+ * can easily run out of memory or disk space. This function ensures that all
+ * created resources are properly cleaned up after every executed test.
+ *
+ * This clean-up only exists in this script, since SimpleTest module itself does
+ * not use isolated sub-processes for each test being run, so a fatal error
+ * halts not only the test, but also the test runner (i.e., the parent site).
+ *
+ * @param int $test_id
+ *   The test ID of the test run.
+ * @param string $test_class
+ *   The class name of the test run.
+ * @param int $exitcode
+ *   The exit code of the test runner.
+ *
+ * @see simpletest_script_run_one_test()
+ */
+function simpletest_script_cleanup($test_id, $test_class, $exitcode) {
+  if (is_subclass_of($test_class, TestCase::class)) {
+    // PHPUnit test, move on.
+    return;
+  }
+  // Retrieve the last database prefix used for testing.
+  try {
+    list($db_prefix) = simpletest_last_test_get($test_id);
+  }
+  catch (Exception $e) {
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+
+  // If no database prefix was found, then the test was not set up correctly.
+  if (empty($db_prefix)) {
+    echo "\nFATAL $test_class: Found no database prefix for test ID $test_id. (Check whether setUp() is invoked correctly.)";
+    return;
+  }
+
+  // Do not output verbose cleanup messages in case of a positive exitcode.
+  $output = !empty($exitcode);
+  $messages = array();
+
+  $messages[] = "- Found database prefix '$db_prefix' for test ID $test_id.";
+
+  // Read the log file in case any fatal errors caused the test to crash.
+  try {
+    simpletest_log_read($test_id, $db_prefix, $test_class);
+  }
+  catch (Exception $e) {
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+
+  // Check whether a test site directory was setup already.
+  // @see \Drupal\simpletest\TestBase::prepareEnvironment()
+  $test_db = new TestDatabase($db_prefix);
+  $test_directory = DRUPAL_ROOT . '/' . $test_db->getTestSitePath();
+  if (is_dir($test_directory)) {
+    // Output the error_log.
+    if (is_file($test_directory . '/error.log')) {
+      if ($errors = file_get_contents($test_directory . '/error.log')) {
+        $output = TRUE;
+        $messages[] = $errors;
+      }
+    }
+    // Delete the test site directory.
+    // simpletest_clean_temporary_directories() cannot be used here, since it
+    // would also delete file directories of other tests that are potentially
+    // running concurrently.
+    file_unmanaged_delete_recursive($test_directory, array('Drupal\simpletest\TestBase', 'filePreDeleteCallback'));
+    $messages[] = "- Removed test site directory.";
+  }
+
+  // Clear out all database tables from the test.
+  try {
+    $schema = Database::getConnection('default', 'default')->schema();
+    $count = 0;
+    foreach ($schema->findTables($db_prefix . '%') as $table) {
+      $schema->dropTable($table);
+      $count++;
+    }
+  }
+  catch (Exception $e) {
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+
+  if ($count) {
+    $messages[] = "- Removed $count leftover tables.";
+  }
+
+  if ($output) {
+    echo implode("\n", $messages);
+    echo "\n";
+  }
+}
+
+/**
+ * Get list of tests based on arguments.
+ *
+ * If --all specified then return all available tests, otherwise reads list of
+ * tests.
+ *
+ * @return array
+ *   List of tests.
+ */
+function simpletest_script_get_test_list() {
+  global $args;
+
+  $types_processed = empty($args['types']);
+  $test_list = array();
+  if ($args['all'] || $args['module']) {
+    try {
+      $groups = simpletest_test_get_all($args['module'], $args['types']);
+      $types_processed = TRUE;
+    }
+    catch (Exception $e) {
+      echo (string) $e;
+      exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+    }
+    $all_tests = array();
+    foreach ($groups as $group => $tests) {
+      $all_tests = array_merge($all_tests, array_keys($tests));
+    }
+    $test_list = $all_tests;
+  }
+  else {
+    if ($args['class']) {
+      $test_list = array();
+      foreach ($args['test_names'] as $test_class) {
+        list($class_name) = explode('::', $test_class, 2);
+        if (class_exists($class_name)) {
+          $test_list[] = $test_class;
+        }
+        else {
+          try {
+            $groups = simpletest_test_get_all(NULL, $args['types']);
+          }
+          catch (Exception $e) {
+            echo (string) $e;
+            exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+          }
+          $all_classes = array();
+          foreach ($groups as $group) {
+            $all_classes = array_merge($all_classes, array_keys($group));
+          }
+          simpletest_script_print_error('Test class not found: ' . $class_name);
+          simpletest_script_print_alternatives($class_name, $all_classes, 6);
+          exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+        }
+      }
+    }
+    elseif ($args['file']) {
+      // Extract test case class names from specified files.
+      foreach ($args['test_names'] as $file) {
+        if (!file_exists($file)) {
+          simpletest_script_print_error('File not found: ' . $file);
+          exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+        }
+        $content = file_get_contents($file);
+        // Extract a potential namespace.
+        $namespace = FALSE;
+        if (preg_match('@^namespace ([^ ;]+)@m', $content, $matches)) {
+          $namespace = $matches[1];
+        }
+        // Extract all class names.
+        // Abstract classes are excluded on purpose.
+        preg_match_all('@^class ([^ ]+)@m', $content, $matches);
+        if (!$namespace) {
+          $test_list = array_merge($test_list, $matches[1]);
+        }
+        else {
+          foreach ($matches[1] as $class_name) {
+            $namespace_class = $namespace . '\\' . $class_name;
+            if (is_subclass_of($namespace_class, '\Drupal\simpletest\TestBase') || is_subclass_of($namespace_class, TestCase::class)) {
+              $test_list[] = $namespace_class;
+            }
+          }
+        }
+      }
+    }
+    elseif ($args['directory']) {
+      // Extract test case class names from specified directory.
+      // Find all tests in the PSR-X structure; Drupal\$extension\Tests\*.php
+      // Since we do not want to hard-code too many structural file/directory
+      // assumptions about PSR-0/4 files and directories, we check for the
+      // minimal conditions only; i.e., a '*.php' file that has '/Tests/' in
+      // its path.
+      // Ignore anything from third party vendors.
+      $ignore = array('.', '..', 'vendor');
+      $files = [];
+      if ($args['directory'][0] === '/') {
+        $directory = $args['directory'];
+      }
+      else {
+        $directory = DRUPAL_ROOT . "/" . $args['directory'];
+      }
+      foreach (file_scan_directory($directory, '/\.php$/', $ignore) as $file) {
+        // '/Tests/' can be contained anywhere in the file's path (there can be
+        // sub-directories below /Tests), but must be contained literally.
+        // Case-insensitive to match all Simpletest and PHPUnit tests:
+        // ./lib/Drupal/foo/Tests/Bar/Baz.php
+        // ./foo/src/Tests/Bar/Baz.php
+        // ./foo/tests/Drupal/foo/Tests/FooTest.php
+        // ./foo/tests/src/FooTest.php
+        // $file->filename doesn't give us a directory, so we use $file->uri
+        // Strip the drupal root directory and trailing slash off the URI.
+        $filename = substr($file->uri, strlen(DRUPAL_ROOT) + 1);
+        if (stripos($filename, '/Tests/')) {
+          $files[$filename] = $filename;
+        }
+      }
+      foreach ($files as $file) {
+        $content = file_get_contents($file);
+        // Extract a potential namespace.
+        $namespace = FALSE;
+        if (preg_match('@^\s*namespace ([^ ;]+)@m', $content, $matches)) {
+          $namespace = $matches[1];
+        }
+        // Extract all class names.
+        // Abstract classes are excluded on purpose.
+        preg_match_all('@^\s*class ([^ ]+)@m', $content, $matches);
+        if (!$namespace) {
+          $test_list = array_merge($test_list, $matches[1]);
+        }
+        else {
+          foreach ($matches[1] as $class_name) {
+            $namespace_class = $namespace . '\\' . $class_name;
+            if (is_subclass_of($namespace_class, '\Drupal\simpletest\TestBase') || is_subclass_of($namespace_class, TestCase::class)) {
+              $test_list[] = $namespace_class;
+            }
+          }
+        }
+      }
+    }
+    else {
+      try {
+        $groups = simpletest_test_get_all(NULL, $args['types']);
+        $types_processed = TRUE;
+      }
+      catch (Exception $e) {
+        echo (string) $e;
+        exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+      }
+      foreach ($args['test_names'] as $group_name) {
+        if (isset($groups[$group_name])) {
+          $test_list = array_merge($test_list, array_keys($groups[$group_name]));
+        }
+        else {
+          simpletest_script_print_error('Test group not found: ' . $group_name);
+          simpletest_script_print_alternatives($group_name, array_keys($groups));
+          exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+        }
+      }
+    }
+  }
+
+  // If the test list creation does not automatically limit by test type then
+  // we need to do so here.
+  if (!$types_processed) {
+    $test_list = array_filter($test_list, function ($test_class) use ($args) {
+      $test_info = TestDiscovery::getTestInfo($test_class);
+      return in_array($test_info['type'], $args['types'], TRUE);
+    });
+  }
+
+  if (empty($test_list)) {
+    simpletest_script_print_error('No valid tests were specified.');
+    exit(SIMPLETEST_SCRIPT_EXIT_FAILURE);
+  }
+  return $test_list;
+}
+
+/**
+ * Initialize the reporter.
+ */
+function simpletest_script_reporter_init() {
+  global $args, $test_list, $results_map;
+
+  $results_map = array(
+    'pass' => 'Pass',
+    'fail' => 'Fail',
+    'exception' => 'Exception',
+  );
+
+  echo "\n";
+  echo "Drupal test run\n";
+  echo "---------------\n";
+  echo "\n";
+
+  // Tell the user about what tests are to be run.
+  if ($args['all']) {
+    echo "All tests will run.\n\n";
+  }
+  else {
+    echo "Tests to be run:\n";
+    foreach ($test_list as $class_name) {
+      echo "  - $class_name\n";
+    }
+    echo "\n";
+  }
+
+  echo "Test run started:\n";
+  echo "  " . date('l, F j, Y - H:i', $_SERVER['REQUEST_TIME']) . "\n";
+  Timer::start('run-tests');
+  echo "\n";
+
+  echo "Test summary\n";
+  echo "------------\n";
+  echo "\n";
+}
+
+/**
+ * Displays the assertion result summary for a single test class.
+ *
+ * @param string $class
+ *   The test class name that was run.
+ * @param array $results
+ *   The assertion results using #pass, #fail, #exception, #debug array keys.
+ */
+function simpletest_script_reporter_display_summary($class, $results) {
+  // Output all test results vertically aligned.
+  // Cut off the class name after 60 chars, and pad each group with 3 digits
+  // by default (more than 999 assertions are rare).
+  $output = vsprintf('%-60.60s %10s %9s %14s %12s', array(
+    $class,
+    $results['#pass'] . ' passes',
+    !$results['#fail'] ? '' : $results['#fail'] . ' fails',
+    !$results['#exception'] ? '' : $results['#exception'] . ' exceptions',
+    !$results['#debug'] ? '' : $results['#debug'] . ' messages',
+  ));
+
+  $status = ($results['#fail'] || $results['#exception'] ? 'fail' : 'pass');
+  simpletest_script_print($output . "\n", simpletest_script_color_code($status));
+}
+
+/**
+ * Display jUnit XML test results.
+ */
+function simpletest_script_reporter_write_xml_results() {
+  global $args, $test_ids, $results_map;
+
+  try {
+    $results = simpletest_script_load_messages_by_test_id($test_ids);
+  }
+  catch (Exception $e) {
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+
+  $test_class = '';
+  $xml_files = array();
+
+  foreach ($results as $result) {
+    if (isset($results_map[$result->status])) {
+      if ($result->test_class != $test_class) {
+        // We've moved onto a new class, so write the last classes results to a
+        // file:
+        if (isset($xml_files[$test_class])) {
+          file_put_contents($args['xml'] . '/' . str_replace('\\', '_', $test_class) . '.xml', $xml_files[$test_class]['doc']->saveXML());
+          unset($xml_files[$test_class]);
+        }
+        $test_class = $result->test_class;
+        if (!isset($xml_files[$test_class])) {
+          $doc = new DomDocument('1.0');
+          $root = $doc->createElement('testsuite');
+          $root = $doc->appendChild($root);
+          $xml_files[$test_class] = array('doc' => $doc, 'suite' => $root);
+        }
+      }
+
+      // For convenience:
+      $dom_document = &$xml_files[$test_class]['doc'];
+
+      // Create the XML element for this test case:
+      $case = $dom_document->createElement('testcase');
+      $case->setAttribute('classname', $test_class);
+      if (strpos($result->function, '->') !== FALSE) {
+        list($class, $name) = explode('->', $result->function, 2);
+      }
+      else {
+        $name = $result->function;
+      }
+      $case->setAttribute('name', $name);
+
+      // Passes get no further attention, but failures and exceptions get to add
+      // more detail:
+      if ($result->status == 'fail') {
+        $fail = $dom_document->createElement('failure');
+        $fail->setAttribute('type', 'failure');
+        $fail->setAttribute('message', $result->message_group);
+        $text = $dom_document->createTextNode($result->message);
+        $fail->appendChild($text);
+        $case->appendChild($fail);
+      }
+      elseif ($result->status == 'exception') {
+        // In the case of an exception the $result->function may not be a class
+        // method so we record the full function name:
+        $case->setAttribute('name', $result->function);
+
+        $fail = $dom_document->createElement('error');
+        $fail->setAttribute('type', 'exception');
+        $fail->setAttribute('message', $result->message_group);
+        $full_message = $result->message . "\n\nline: " . $result->line . "\nfile: " . $result->file;
+        $text = $dom_document->createTextNode($full_message);
+        $fail->appendChild($text);
+        $case->appendChild($fail);
+      }
+      // Append the test case XML to the test suite:
+      $xml_files[$test_class]['suite']->appendChild($case);
+    }
+  }
+  // The last test case hasn't been saved to a file yet, so do that now:
+  if (isset($xml_files[$test_class])) {
+    file_put_contents($args['xml'] . '/' . str_replace('\\', '_', $test_class) . '.xml', $xml_files[$test_class]['doc']->saveXML());
+    unset($xml_files[$test_class]);
+  }
+}
+
+/**
+ * Stop the test timer.
+ */
+function simpletest_script_reporter_timer_stop() {
+  echo "\n";
+  $end = Timer::stop('run-tests');
+  echo "Test run duration: " . \Drupal::service('date.formatter')->formatInterval($end['time'] / 1000);
+  echo "\n\n";
+}
+
+/**
+ * Display test results.
+ */
+function simpletest_script_reporter_display_results() {
+  global $args, $test_ids, $results_map;
+
+  if ($args['verbose']) {
+    // Report results.
+    echo "Detailed test results\n";
+    echo "---------------------\n";
+
+    try {
+      $results = simpletest_script_load_messages_by_test_id($test_ids);
+    }
+    catch (Exception $e) {
+      echo (string) $e;
+      exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+    }
+    $test_class = '';
+    foreach ($results as $result) {
+      if (isset($results_map[$result->status])) {
+        if ($result->test_class != $test_class) {
+          // Display test class every time results are for new test class.
+          echo "\n\n---- $result->test_class ----\n\n\n";
+          $test_class = $result->test_class;
+
+          // Print table header.
+          echo "Status    Group      Filename          Line Function                            \n";
+          echo "--------------------------------------------------------------------------------\n";
+        }
+
+        simpletest_script_format_result($result);
+      }
+    }
+  }
+}
+
+/**
+ * Format the result so that it fits within 80 characters.
+ *
+ * @param object $result
+ *   The result object to format.
+ */
+function simpletest_script_format_result($result) {
+  global $args, $results_map, $color;
+
+  $summary = sprintf("%-9.9s %-10.10s %-17.17s %4.4s %-35.35s\n",
+    $results_map[$result->status], $result->message_group, basename($result->file), $result->line, $result->function);
+
+  simpletest_script_print($summary, simpletest_script_color_code($result->status));
+
+  $message = trim(strip_tags($result->message));
+  if ($args['non-html']) {
+    $message = Html::decodeEntities($message, ENT_QUOTES, 'UTF-8');
+  }
+  $lines = explode("\n", wordwrap($message), 76);
+  foreach ($lines as $line) {
+    echo "    $line\n";
+  }
+}
+
+/**
+ * Print error messages so the user will notice them.
+ *
+ * Print error message prefixed with "  ERROR: " and displayed in fail color if
+ * color output is enabled.
+ *
+ * @param string $message
+ *   The message to print.
+ */
+function simpletest_script_print_error($message) {
+  simpletest_script_print("  ERROR: $message\n", SIMPLETEST_SCRIPT_COLOR_FAIL);
+}
+
+/**
+ * Print a message to the console, using a color.
+ *
+ * @param string $message
+ *   The message to print.
+ * @param int $color_code
+ *   The color code to use for coloring.
+ */
+function simpletest_script_print($message, $color_code) {
+  global $args;
+  if ($args['color']) {
+    echo "\033[" . $color_code . "m" . $message . "\033[0m";
+  }
+  else {
+    echo $message;
+  }
+}
+
+/**
+ * Get the color code associated with the specified status.
+ *
+ * @param string $status
+ *   The status string to get code for. Special cases are: 'pass', 'fail', or
+ *   'exception'.
+ *
+ * @return int
+ *   Color code. Returns 0 for default case.
+ */
+function simpletest_script_color_code($status) {
+  switch ($status) {
+    case 'pass':
+      return SIMPLETEST_SCRIPT_COLOR_PASS;
+
+    case 'fail':
+      return SIMPLETEST_SCRIPT_COLOR_FAIL;
+
+    case 'exception':
+      return SIMPLETEST_SCRIPT_COLOR_EXCEPTION;
+  }
+  // Default formatting.
+  return 0;
+}
+
+/**
+ * Prints alternative test names.
+ *
+ * Searches the provided array of string values for close matches based on the
+ * Levenshtein algorithm.
+ *
+ * @param string $string
+ *   A string to test.
+ * @param array $array
+ *   A list of strings to search.
+ * @param int $degree
+ *   The matching strictness. Higher values return fewer matches. A value of
+ *   4 means that the function will return strings from $array if the candidate
+ *   string in $array would be identical to $string by changing 1/4 or fewer of
+ *   its characters.
+ *
+ * @see http://php.net/manual/en/function.levenshtein.php
+ */
+function simpletest_script_print_alternatives($string, $array, $degree = 4) {
+  $alternatives = array();
+  foreach ($array as $item) {
+    $lev = levenshtein($string, $item);
+    if ($lev <= strlen($item) / $degree || FALSE !== strpos($string, $item)) {
+      $alternatives[] = $item;
+    }
+  }
+  if (!empty($alternatives)) {
+    simpletest_script_print("  Did you mean?\n", SIMPLETEST_SCRIPT_COLOR_FAIL);
+    foreach ($alternatives as $alternative) {
+      simpletest_script_print("  - $alternative\n", SIMPLETEST_SCRIPT_COLOR_FAIL);
+    }
+  }
+}
+
+/**
+ * Loads the simpletest messages from the database.
+ *
+ * Messages are ordered by test class and message id.
+ *
+ * @param array $test_ids
+ *   Array of test IDs of the messages to be loaded.
+ *
+ * @return array
+ *   Array of simpletest messages from the database.
+ */
+function simpletest_script_load_messages_by_test_id($test_ids) {
+  global $args;
+  $results = array();
+
+  // Sqlite has a maximum number of variables per query. If required, the
+  // database query is split into chunks.
+  if (count($test_ids) > SIMPLETEST_SCRIPT_SQLITE_VARIABLE_LIMIT && !empty($args['sqlite'])) {
+    $test_id_chunks = array_chunk($test_ids, SIMPLETEST_SCRIPT_SQLITE_VARIABLE_LIMIT);
+  }
+  else {
+    $test_id_chunks = array($test_ids);
+  }
+
+  foreach ($test_id_chunks as $test_id_chunk) {
+    try {
+      $result_chunk = Database::getConnection('default', 'test-runner')
+        ->query("SELECT * FROM {simpletest} WHERE test_id IN ( :test_ids[] ) ORDER BY test_class, message_id", array(
+          ':test_ids[]' => $test_id_chunk,
+        ))->fetchAll();
+    }
+    catch (Exception $e) {
+      echo (string) $e;
+      exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+    }
+    if ($result_chunk) {
+      $results = array_merge($results, $result_chunk);
+    }
+  }
+
+  return $results;
+}
+
+/**
+ * Display test results.
+ */
+function simpletest_script_open_browser() {
+  global $test_ids;
+
+  try {
+    $connection = Database::getConnection('default', 'test-runner');
+    $results = $connection->select('simpletest')
+      ->fields('simpletest')
+      ->condition('test_id', $test_ids, 'IN')
+      ->orderBy('test_class')
+      ->orderBy('message_id')
+      ->execute()
+      ->fetchAll();
+  }
+  catch (Exception $e) {
+    echo (string) $e;
+    exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION);
+  }
+
+  // Get the results form.
+  $form = array();
+  SimpletestResultsForm::addResultForm($form, $results);
+
+  // Get the assets to make the details element collapsible and theme the result
+  // form.
+  $assets = new \Drupal\Core\Asset\AttachedAssets();
+  $assets->setLibraries([
+    'core/drupal.collapse',
+    'system/admin',
+    'simpletest/drupal.simpletest',
+  ]);
+  $resolver = \Drupal::service('asset.resolver');
+  list($js_assets_header, $js_assets_footer) = $resolver->getJsAssets($assets, FALSE);
+  $js_collection_renderer = \Drupal::service('asset.js.collection_renderer');
+  $js_assets_header = $js_collection_renderer->render($js_assets_header);
+  $js_assets_footer = $js_collection_renderer->render($js_assets_footer);
+  $css_assets = \Drupal::service('asset.css.collection_renderer')->render($resolver->getCssAssets($assets, FALSE));
+
+  // Make the html page to write to disk.
+  $render_service = \Drupal::service('renderer');
+  $html = '<head>' . $render_service->renderPlain($js_assets_header) . $render_service->renderPlain($css_assets) . '</head><body>' . $render_service->renderPlain($form) . $render_service->renderPlain($js_assets_footer) . '</body>';
+
+  // Ensure we have assets verbose directory - tests with no verbose output will
+  // not have created one.
+  $directory = PublicStream::basePath() . '/simpletest/verbose';
+  file_prepare_directory($directory, FILE_CREATE_DIRECTORY | FILE_MODIFY_PERMISSIONS);
+  $php = new Php();
+  $uuid = $php->generate();
+  $filename = $directory . '/results-' . $uuid . '.html';
+  $base_url = getenv('SIMPLETEST_BASE_URL');
+  if (empty($base_url)) {
+    simpletest_script_print_error("--browser needs argument --url.");
+  }
+  $url = $base_url . '/' . PublicStream::basePath() . '/simpletest/verbose/results-' . $uuid . '.html';
+  file_put_contents($filename, $html);
+
+  // See if we can find an OS helper to open URLs in default browser.
+  $browser = FALSE;
+  if (shell_exec('which xdg-open')) {
+    $browser = 'xdg-open';
+  }
+  elseif (shell_exec('which open')) {
+    $browser = 'open';
+  }
+  elseif (substr(PHP_OS, 0, 3) == 'WIN') {
+    $browser = 'start';
+  }
+
+  if ($browser) {
+    shell_exec($browser . ' ' . escapeshellarg($url));
+  }
+  else {
+    // Can't find assets valid browser.
+    print 'Open file://' . realpath($filename) . ' in your browser to see the verbose output.';
+  }
+}