diff --git a/.env.default b/.env.default
index 848e9c9..84de84c 100644
--- a/.env.default
+++ b/.env.default
@@ -59,4 +59,20 @@ export WPT_SSH_PRIVATE_KEY_BASE64=
 
 # Output logging
 # Use 'verbose' to increase verbosity
-export WPT_DEBUG=
\ No newline at end of file
+export WPT_DEBUG=
+
+# Certificate validation
+# Use 1 to validate, and 0 to not validate
+export WPT_CERTIFICATE_VALIDATION=1
+
+# WordPress flavor
+# 0 = WordPress (simple version)
+# 1 = WordPress Multisite
+export WPT_FLAVOR=1
+
+# Extra tests (groups)
+# 0 = none
+# 1 = ajax
+# 2 = ms-files
+# 3 = external-http
+export WPT_EXTRATESTS=0
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index d3f46f2..a71895b 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -20,6 +20,7 @@ on:
      # - cron:  '0 0 * * *'
      # Every 30 minutes.
      # - cron:  '0/30 * * * *'
+   workflow_dispatch:
 
 # Cancels all previous workflow runs for pull requests that have not completed.
 concurrency:
@@ -42,7 +43,7 @@ jobs:
   test:
     name: Run Core PHPUnit tests
     runs-on: ubuntu-latest
-
+    
     # Remove this line if Github Actions is your preferred means of running the tests.
     if: ${{ false }}
 
@@ -63,16 +64,16 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f # v2.3.4
+        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v3.5.2
 
       - name: Set up PHP
-        uses: shivammathur/setup-php@947009a71769c25ab5292f073f5343624b7c879d # v2.12.0
+        uses: shivammathur/setup-php@c5fc0d8281aba02c7fda07d3a70cc5371548067d # v2.25.2
         with:
           php-version: '7.4'
           coverage: none
 
       - name: Install NodeJS
-        uses: actions/setup-node@25316bbc1f10ac9d8798711f44914b1cf3c4e954 # v2.4.0
+        uses: actions/setup-node@64ed1c7eab4cce3362f8c340dee64e5eaeef8f7c # v3.6.0
         with:
           node-version: 14
 
diff --git a/.gitignore b/.gitignore
index b1b8150..0721216 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 .DS_Store
 .env*
 vendor/
+package-lock.json
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
index c406a62..71890f8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,6 @@
 language: php
 node_js:
-  - node
+  - 14
 
 before_install:
   - npm install -g npm@latest
diff --git a/README.md b/README.md
index f6a3a55..046dfad 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# phpunit-test-runner
+# PHPUnit Test Runner
 
 Thanks for running the WordPress PHPUnit test suite on your infrastructure. We appreciate you helping to ensure WordPress’s compatibility for your users.
 
-If you haven't already, [please first read through the "Getting Started" documentation](https://make.wordpress.org/hosting/test-results-getting-started/).
+If you haven't already, [please first read through the "Getting Started" documentation](https://make.wordpress.org/hosting/handbook/tests/).
 
-The test suite runner is designed to be used without any file modification. Configuration happens with a series of environment variables (see [.env.default](.env.default) for an annotated overview). Use the [repository wiki](../../wiki) to document implementation details, to avoid README conflicts with the upstream.
+The test suite runner is designed to be used without any file modification. Configuration happens with a series of environment variables (see [.env.default](.env.default) for an annotated overview).
 
 At a high level, the test suite runner:
 
@@ -13,7 +13,7 @@ At a high level, the test suite runner:
 3. Reports the PHPUnit test results to WordPress.org
 4. Cleans up the test suite environment.
 
-## Configuring
+## Setup
 
 The test suite runner can be used in one of two ways:
 
@@ -24,94 +24,373 @@ The test runner is configured through environment variables, documented in [`.en
 
 With a direct Git clone, you can:
 
-    # Copy the default .env file.
-    cp .env.default .env
-    # Edit the .env file to define your variables.
-    vim .env
-    # Load your variables into scope.
-    source .env
+```bash
+# Copy the default .env file.
+cp .env.default .env
+# Edit the .env file to define your variables.
+vim .env
+# Load your variables into scope.
+source .env
+```
 
 In a CI service, you can set these environment variables through the service's web console. Importantly, the `WPT_SSH_CONNECT` environment variable determines whether the test suite is run locally or against a remote environment.
 
 Concurrently run tests in the same environment by appending build ids to the test directory and table prefix:
 
-    export WPT_TEST_DIR=wp-test-runner-$TRAVIS_BUILD_NUMBER
-    export WPT_TABLE_PREFIX=wptests_$TRAVIS_BUILD_NUMBER\_
+```bash
+export WPT_TEST_DIR=wp-test-runner-$TRAVIS_BUILD_NUMBER
+export WPT_TABLE_PREFIX=wptests_$TRAVIS_BUILD_NUMBER\_
+```
 
 Connect to a remote environment over SSH by having the CI job provision the SSH key:
 
-    # 1. Create a SSH key pair for the controller to use
-    ssh-keygen -t rsa -b 4096 -C "travis@travis-ci.org"
-    # 2. base64 encode the private key for use with the environment variable
-    cat ~/.ssh/id_rsa | base64 --wrap=0
-    # 3. Append id_rsa.pub to authorized_keys so the CI service can SSH in
-    cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
+```bash
+# 1. Create a SSH key pair for the controller to use
+ssh-keygen -t rsa -b 4096 -C "travis@travis-ci.org"
+# 2. base64 encode the private key for use with the environment variable
+cat ~/.ssh/id_rsa | base64 --wrap=0
+# 3. Append id_rsa.pub to authorized_keys so the CI service can SSH in
+cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
+```
+
+Use a more complex SSH connection process by creating an SSH alias:
+
+```bash
+# 1. Add the following to ~/.ssh/config to create a 'wpt' alias
+Host wpt
+  Hostname 123.45.67.89
+  User wpt
+  Port 1234
+# 2. Use 'wpt' wherever you might normally use a SSH connection string
+ssh wpt
+```
 
-Use a more complex SSH connection process by creating a SSH alias:
+## Running
 
-    # 1. Add the following to ~/.ssh/config to create a 'wpt' alias
-    Host wpt
-      Hostname 123.45.67.89
-      User wpt
-      Port 1234
-    # 2. Use 'wpt' wherever you might normally use a SSH connection string
-    ssh wpt
+The test suite runner is run in four steps. This explanation is for the local execution.
 
-## Running
+### Requirements
 
-The test suite runner is run in four steps.
+To use the Runner, the following is required (testing WordPress 6.5):
 
-### 0. Requirements
+- Server / hosting (infrastructure) with the usual configuration you use
+- A database where you can test (tables will be created and destroyed several times)
+- PHP 7.0+ (view )
+- MySQL 5.5+ / MariaDB 10.0+
+- NodeJS 20.x / npm 10.x / grunt
+- PHP Composer
+- Git, RSync, WGet, UnZip
 
-Both the prep and test environments must meet some basic requirements.
+Test environment:
 
-Prep environment:
+- Writable filesystem for the entire test directory (see [#40910](https://core.trac.wordpress.org/ticket/40910)).
+- Run with a non-root user, both for security and practical purposes (see [#44233](https://core.trac.wordpress.org/ticket/44233#comment:34)/[#46577](https://core.trac.wordpress.org/ticket/46577)).
 
-* PHP 5.6 or greater (to run scripts).
-* Utilities: `git` version 1.8.5 or greater, `rsync`, `wget`, `unzip`.
-* Node.js including `npm` and `grunt` packages
+#### Database creation
 
-Test environment:
+_This is an example for MySQL / MariaDB._
+
+```sql
+CREATE DATABASE wordpressdatabase CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci;
+GRANT ALL ON wordpressdatabase.* TO 'wordpressusername'@'localhost' IDENTIFIED BY 'wordpresspassword';
+GRANT ALL ON wordpressdatabase.* TO 'wordpressusername'@'127.0.0.1' IDENTIFIED BY 'wordpresspassword';
+FLUSH PRIVILEGES;
+```
+
+#### NodeJS installation
+
+_This is an example for Debian / Ubuntu._
+
+```bash
+curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
+sudo apt -y install nodejs
+sudo npm install -g npm@latest
+nodejs --version
+npm --version
+```
+
+#### PHP Composer
+
+_This is an example for Debian / Ubuntu._
+
+```bash
+curl -sS https://getcomposer.org/installer -o composer-setup.php
+php composer-setup.php --install-dir=/usr/local/bin --filename=composer
+composer --version
+```
+
+#### Git
+
+_This is an example for Debian / Ubuntu._
+
+```bash
+apt -y install git
+git --version
+```
+
+### Installing the Test Runner
+
+First, download the software. This example uses `/home/wptestrunner/` folder, but set the best for this environment.
+
+```bash
+cd /home/wptestrunner/
+git clone https://github.com/WordPress/phpunit-test-runner.git
+cd phpunit-test-runner/
+```
+
+The next step will be to configure the environment. To do this, make a copy of the example file and then configure it.
+
+```bash
+cp .env.default .env
+vim .env
+```
+
+The content (in summary form) can be something like this:
+
+```bash
+###
+# Configuration environment variables used by the test runner
+#
+# # Create a copy for your local environment
+# $ cp .env.default .env
+#
+# # Make any necessary changes to the default values
+# $ vim .env
+#
+# # Load your variables into your environment
+# $ source .env
+###
+
+# Path to the directory where files can be prepared before being delivered to the environment.
+export WPT_PREPARE_DIR=/tmp/wp-test-runner
+
+# Path to the directory where the WordPress develop checkout can be placed and tests can be run.
+# When running tests in the same environment, set WPT_TEST_DIR to WPT_PREPARE_DIR
+export WPT_TEST_DIR=/tmp/wp-test-runner
+
+# API key to authenticate with the reporting service in 'username:password' format.
+export WPT_REPORT_API_KEY=
+
+# (Optionally) define an alternate reporting URL
+export WPT_REPORT_URL=
+
+# Credentials for a database that can be written to and reset.
+# WARNING!!! This database will be destroyed between tests. Only use safe database credentials.
+# Please note that you must escape _or_ refrain from using # as special character in your credentials.
+export WPT_DB_NAME=
+export WPT_DB_USER=
+export WPT_DB_PASSWORD=
+export WPT_DB_HOST=
+
+# (Optionally) set a custom table prefix to permit concurrency against the same database.
+export WPT_TABLE_PREFIX=${WPT_TABLE_PREFIX-wptests_}
+
+# (Optionally) define the PHP executable to be called
+export WPT_PHP_EXECUTABLE=${WPT_PHP_EXECUTABLE-php}
+
+# (Optionally) define the PHPUnit command execution call.
+# Use if `php phpunit.phar` can't be called directly for some reason.
+export WPT_PHPUNIT_CMD=
+
+# (Optionally) define the command execution to remove the test directory
+# Use if `rm -r` can't be called directly for some reason.
+export WPT_RM_TEST_DIR_CMD=
+
+# SSH connection string (can also be an alias).
+# Leave empty if tests are meant to run in the same environment.
+export WPT_SSH_CONNECT=
+
+# Any options to be passed to the SSH connection
+# Defaults to '-o StrictHostKeyChecking=no'
+export WPT_SSH_OPTIONS=
+
+# SSH private key, base64 encoded.
+export WPT_SSH_PRIVATE_KEY_BASE64=
+
+# Output logging
+# Use 'verbose' to increase verbosity
+export WPT_DEBUG=
+
+# Certificate validation
+# Use 1 to validate, and 0 to not validate
+export WPT_CERTIFICATE_VALIDATION=1
+
+# WordPress flavor
+# 0 = WordPress (simple version)
+# 1 = WordPress Multisite
+export WPT_FLAVOR=1
+
+# Extra tests (groups)
+# 0 = none
+# 1 = ajax
+# 2 = ms-files
+# 3 = external-http
+export WPT_EXTRATESTS=0
+```
+
+Configure the folder where the WordPress software downloads and the database accesses will be made in order to prepare the tests.
+
+### Preparing the environment
+
+Before performing the first test, let’s update all the components. This process can be run before each test in this environment if wanted to keep it up to date, although it will depend more if it is in a production environment.
+
+```bash
+cd /home/wptestrunner/phpunit-test-runner/
+git pull
+source .env
+git checkout master
+```
+
+If you want to check a different branch, you can change it doing:
+
+```bash
+git checkout example-branch
+```
+
+## Preparing the test
+
+Now there is the environment ready, run the test preparation.
+
+```bash
+php prepare.php
+```
+
+The system will run a long series of installations, configurations and compilations of different elements in order to prepare the test. If warnings and warnings come out you should not worry too much, as it is quite normal. At the end of the process it will warn you if it needs something it doesn’t have. If it works, you should see something like this at the end:
+
+```
+Success: Prepared environment.
+```
+
+Now that the environment has been prepared, the next step is to run the tests for the first time.
+
+### Running the test
+
+Now that the environment is ready, let’s run the tests. To do this, execute the file that will perform it.
+
+```bash
+php test.php
+```
+
+What do the symbols mean?
+
+`.` → Each dot means that the test has been passed correctly.
+
+`S` → It means the test has been skipped. This is usually because these tests are only valid in certain configurations.
+
+`F` → Means that the test has failed. Information about why this happened is displayed at the end.
+
+`E` → It means that the test has failed due to a PHP error, which can be an error, warning or notice.
+
+`I` → Means that the test has been marked as incomplete.
+
+If you follow these steps, everything should work perfectly and not make any mistakes. In case you get any error, it may be normal due to some missing adjustment or extension of PHP, among others. We recommend that you adjust the configuration until it works correctly. After all, this tool is to help you improve the optimal configuration for WordPress in that infrastructure.
+
+### Creating a report
+
+Even if the test has failed, a report will be made. The first one shows the information about our environment. Among the most important elements are the extensions that are commonly used in WordPress and some utilities that are also generally useful.
+
+```bash
+cat /tmp/wp-test-runner/tests/phpunit/build/logs/env.json
+```
 
-* PHP 5.6 or greater with Phar support enabled (for PHPUnit).
-* MySQL or MariaDB with access to a writable database.
-* Writable filesystem for the entire test directory (see [#40910](https://core.trac.wordpress.org/ticket/40910)).
-* Run with a non-root user, both for security and practical purposes (see [#44233](https://core.trac.wordpress.org/ticket/44233#comment:34)/[#46577](https://core.trac.wordpress.org/ticket/46577)).
+The content of this file is somewhat similar to this:
 
-### 1. Prepare
+```bash
+{
+  "php_version": "7.4.5",
+  "php_modules": {
+    "bcmath": false,
+    "curl": "7.4.5",
+    "filter": "7.4.5",
+    "gd": false,
+    "libsodium": false,
+    "mcrypt": false,
+    "mod_xml": false,
+    "mysqli": "7.4.5",
+    "imagick": false,
+    "pcre": "7.4.5",
+    "xml": "7.4.5",
+    "xmlreader": "7.4.5",
+    "zlib": "7.4.5"
+  },
+  "system_utils": {
+    "curl": "7.58.0 (x86_64-pc-linux-gnu) libcurl\/7.58.0 OpenSSL\/1.1.1g zlib\/1.2.11 libidn2\/2.3.0 libpsl\/0.19.1 (+libidn2\/2.0.4) nghttp2\/1.30.0 librtmp\/2.3",
+    "ghostscript": "",
+    "imagemagick": false,
+    "openssl": "1.1.1g 21 Apr 2020"
+  },
+  "mysql_version": "mysql Ver 15.1 Distrib 10.4.12-MariaDB, for debian-linux-gnu (x86_64) using readline 5.2",
+  "os_name": "Linux",
+  "os_version": "4.15.0-20-generic"
+}
+```
 
-The [`prepare.php`](prepare.php) step:
+In addition to this report, a definitive file with all the information of what happened in the tests. This is the one that includes all the tests that are made (more than 10,000) giving information of the time that they take to be executed, problems that have arisen…
 
-1. Extracts the base64-encoded SSH private key, if necessary.
-2. Clones the master branch of the WordPress develop git repo into the preparation directory.
-3. Downloads `phpunit.phar` to the preparation directory.
-4. Generates `wp-tests-config.php` and puts it into the preparation directory.
-5. Delivers the prepared test directory to the test environment.
+```bash
+cat /tmp/wp-test-runner/tests/phpunit/build/logs/junit.xml
+```
 
-### 2. Test
+At this point we can generate the reports by sending them to WordPress.org, if necessary. Even if you haven’t included the WordPress user (see below for how to create it), you can still run this file.
 
-The [`test.php`](test.php) step:
+```bash
+php report.php
+```
 
-1. Calls `php phpunit.phar` to produce `tests/phpunit/build/logs/junit.xml`.
+### Cleaning up the environment for other tests
 
-### 3. Report
+Having the tests working, all that remains is to delete all the files that have been created so that we can start over. To do this, execute the following command:
 
-The [`report.php`](report.php) step:
+```bash
+php cleanup.php
+```
 
-1. Processes PHPUnit XML log into a JSON blob.
-2. Sends the JSON to WordPress.org.
+### Automatic running
 
-### 4. Cleanup
+The best way to run this test is to create a cron that runs everything. Having in mind that the tests can overlap, the best way can be using a systemd timer.
 
-The [`cleanup.php`](cleanup.php) step:
+```bash
+cat > /etc/systemd/system/wordpressphpunittestrunner.service << EOF
+[Unit]
+Description=WordPress PHPUnit Test Runner
+[Service]
+Type=oneshot
+ExecStart=cd /home/wptestrunner/phpunit-test-runner/ && source .env && php prepare.php && php test.php && php report.php && php cleanup.php
+User=wptestrunner
+Group=wptestrunner
+EOF
+```
 
-1. Resets the database.
-2. Deletes all files delivered to the test environment.
+```bash
+cat > /etc/systemd/system/wordpressphpunittestrunner.timer << EOF
+[Unit]
+Description=WordPress PHPUnit Test Runner
+[Timer]
+OnCalendar=*-*-* *:*:00
+Persistent=true
+[Install]
+WantedBy=timers.target
+EOF
+```
+
+```bash
+systemctl daemon-reload
+systemctl enable wordpressphpunittestrunner.timer
+systemctl start wordpressphpunittestrunner.timer
+systemctl status wordpressphpunittestrunner.timer
+```
+
+If you want to check how is everything working...
+
+```bash
+journalctl -u wordpressphpunittestrunner.timer
+journalctl -n 120 -u wordpressphpunittestrunner.service
+```
 
 ## Contributing
 
-tk
+If you have questions about the process or run into test failures along the way, please [open an issue in the project repository](https://github.com/WordPress/phpunit-test-runner/issues) and we’ll help diagnose/get the documentation updated. Alternatively, you can also pop into the `#hosting` channel on [WordPress.org Slack](https://make.wordpress.org/chat/) for help.
 
 ## License
 
-See [LICENSE](LICENSE) for project license.
+See [LICENSE](LICENSE) for project license.
\ No newline at end of file
diff --git a/cleanup.php b/cleanup.php
index f2e03cf..e584c6c 100644
--- a/cleanup.php
+++ b/cleanup.php
@@ -1,30 +1,51 @@
 <?php
-
 /**
- * Cleans up the environment after the test run.
+ * This script is responsible for cleaning up the test environment after a run of the WordPress PHPUnit Test Runner.
+ * It ensures that temporary directories and files created during the test process are properly deleted.
+ * 
+ * @link https://github.com/wordpress/phpunit-test-runner/ Original source repository
+ * @package WordPress
  */
-
 require __DIR__ . '/functions.php';
 
-// Check required environment variables.
+/**
+ * Check for the presence of required environment variables.
+ * This function should be defined in functions.php and should throw an
+ * exception or exit if any required variables are missing.
+ */
 check_required_env();
 
-// Bring some environment variables into scope.
-$WPT_PREPARE_DIR = getenv( 'WPT_PREPARE_DIR' );
-$WPT_SSH_CONNECT = getenv( 'WPT_SSH_CONNECT' );
-$WPT_SSH_OPTIONS = getenv( 'WPT_SSH_OPTIONS' ) ? : '-o StrictHostKeyChecking=no';
-$WPT_TEST_DIR = getenv( 'WPT_TEST_DIR' );
-$WPT_RM_TEST_DIR_CMD = getenv( 'WPT_RM_TEST_DIR_CMD' ) ? : 'rm -r ' . $WPT_TEST_DIR;
+/**
+ * Retrieves environment variables and sets defaults for test preparation.
+ * These variables are used to configure SSH connections, file paths, and
+ * executable commands needed for setting up the test environment.
+ */
+$WPT_PREPARE_DIR     = trim( getenv( 'WPT_PREPARE_DIR' ) );
+$WPT_SSH_CONNECT     = trim( getenv( 'WPT_SSH_CONNECT' ) );
+$WPT_SSH_OPTIONS     = trim( getenv( 'WPT_SSH_OPTIONS' ) ) ? : '-o StrictHostKeyChecking=no';
+$WPT_TEST_DIR        = trim( getenv( 'WPT_TEST_DIR' ) );
+$WPT_RM_TEST_DIR_CMD = trim( getenv( 'WPT_RM_TEST_DIR_CMD' ) ) ? : 'rm -r ' . $WPT_TEST_DIR;
 
-// Clean up the preparation directory.
-// Only forcefully delete the .git directory, to prevent disasters otherwise.
+/**
+ * The directory path of the test preparation directory is assumed to be previously defined.
+ * For example: $WPT_PREPARE_DIR = '/path/to/your/preparation/dir';
+ * Clean up the preparation directory.
+ * Forcefully deletes only the .git directory and the node_modules cache.
+ * Afterward, the entire preparation directory is removed to ensure a clean state for the next test run.
+ */
 perform_operations( array(
 	'rm -rf ' . escapeshellarg( $WPT_PREPARE_DIR . '/.git' ),
 	'rm -rf ' . escapeshellarg( $WPT_PREPARE_DIR . '/node_modules/.cache' ),
 	'rm -r ' . escapeshellarg( $WPT_PREPARE_DIR ),
 ) );
 
-// Clean up the test directory in remote environments.
+/**
+ * Cleans up the test directory on a remote server.
+ * This conditional block checks if an SSH connection string is provided and is not empty.
+ * If a connection string is present, it triggers a cleanup operation on the remote environment.
+ * The cleanup operation is executed by the `perform_operations` function which takes an array
+ * of shell commands as its input.
+ */
 if ( ! empty( $WPT_SSH_CONNECT ) ) {
 	perform_operations( array(
 		'ssh ' . $WPT_SSH_OPTIONS . ' ' . escapeshellarg( $WPT_SSH_CONNECT ) . ' ' . escapeshellarg( $WPT_RM_TEST_DIR_CMD ),
diff --git a/functions.php b/functions.php
index a74989a..3df9343 100644
--- a/functions.php
+++ b/functions.php
@@ -1,11 +1,20 @@
 <?php
-
-/**
- * Utility functions for the test runner.
- */
-
 /**
- * Check for required environment variables.
+ * Validates the presence of essential environment variables necessary for the application to run correctly.
+ * Specifically checks for variables related to directories and database configuration. It also ensures that
+ * the test and preparation directories are the same when running locally without SSH connection requirements.
+ *
+ * This function will issue error messages through `error_message()` for any missing environment variables
+ * and logs a message upon successful validation of all required variables.
+ *
+ * @param bool $check_db Optional. Whether to include database-related environment variables in the check. Defaults to true.
+ *                       If set to false, database variables (prefixed with 'WPT_DB_') are not checked.
+ *
+ * @return void This function does not return a value but will halt execution if any required environment variable is missing.
+ *
+ * @uses getenv() to retrieve environment variable values.
+ * @uses error_message() to display error messages for missing variables.
+ * @uses log_message() to log a success message when all checks pass.
  */
 function check_required_env( $check_db = true ) {
 
@@ -35,9 +44,22 @@ function check_required_env( $check_db = true ) {
 }
 
 /**
- * Perform some number of shell operations
+ * Executes a series of shell commands provided in the operations array. Each operation is logged before execution.
+ * If any command fails (indicated by a non-zero return code), an error message is displayed. This function is
+ * useful for automating batch shell tasks within a PHP script, with error handling for each operation.
  *
- * @param array $operations
+ * @param array $operations An array of shell commands (strings) to be executed. Each command should be
+ *                          a valid shell command and properly escaped for safety. The commands are executed
+ *                          in the order they appear in the array.
+ *
+ * @return void This function does not return a value. However, it will output the result of each shell command
+ *              to the standard output and log the execution. It will also halt on the first command that fails,
+ *              displaying an error message.
+ *
+ * @uses log_message() to log each operation before execution. This can be used for debugging or auditing purposes.
+ * @uses passthru() to execute the shell command, which provides direct output to the browser. Be aware that using
+ *      this function with untrusted input can lead to security vulnerabilities, such as command injection attacks.
+ * @uses error_message() to display an error message if a shell command fails. The execution stops at the first failure.
  */
 function perform_operations( $operations ) {
 	foreach( $operations as $operation ) {
@@ -50,18 +72,39 @@ function perform_operations( $operations ) {
 }
 
 /**
- * Log a message to STDOUT
+ * Writes a message followed by a newline to the standard output (STDOUT). This function is commonly used for logging purposes,
+ * providing feedback during script execution, or debugging. The message is appended with the PHP end-of-line constant (PHP_EOL)
+ * to ensure proper line breaks on different operating systems.
+ *
+ * @param string $message The message to be logged. This should be a string, and it will be output exactly as provided,
+ *                        followed by a system-specific newline character.
+ *
+ * @return void This function does not return a value. It directly writes the message to STDOUT, which is typically
+ *              visible in the console or terminal where the PHP script is executed.
  *
- * @param string $message
+ * @uses fwrite() to write the message to STDOUT. This is a low-level file operation function that works with various
+ *      file streams, including standard output, standard error, and regular files.
  */
 function log_message( $message ) {
 	fwrite( STDOUT, $message . PHP_EOL );
 }
 
 /**
- * Log an error message to STDERR
+ * Writes an error message prefixed with "Error: " to the standard error output (STDERR) and terminates the script
+ * with a status code of 1. This function is typically used to report errors during script execution, where an
+ * immediate halt is necessary due to unrecoverable conditions. The message is appended with the PHP end-of-line
+ * constant (PHP_EOL) to ensure it is properly displayed on all operating systems.
  *
- * @param string $message
+ * @param string $message The error message to be logged. This string will be output as provided, but prefixed
+ *                        with "Error: " to indicate its nature, followed by a system-specific newline character.
+ *
+ * @return void This function does not return a value. It directly writes the error message to STDERR and then
+ *              terminates the script execution using `exit(1)`, indicating an error condition to the environment.
+ *
+ * @uses fwrite() to write the error message to STDERR. This function is used for low-level writing to file streams
+ *      or output streams, in this case, STDERR, which is specifically for error reporting.
+ * @uses exit() to terminate the script execution with a status code of 1, indicating an error has occurred. This is
+ *      a common practice in command-line scripts and applications to signal failure to the calling process or environment.
  */
 function error_message( $message ) {
 	fwrite( STDERR, 'Error: ' . $message . PHP_EOL );
@@ -69,21 +112,43 @@ function error_message( $message ) {
 }
 
 /**
- * Add a trailing slash to the string
+ * Ensures a single trailing slash is present at the end of a given string. This function first removes any existing
+ * trailing slashes from the input string to avoid duplication and then appends a single slash. It's commonly used
+ * to normalize file paths or URLs to ensure consistency in format, especially when concatenating paths or performing
+ * file system operations that expect a trailing slash.
+ *
+ * @param string $string The input string to which a trailing slash will be added. This could be a file path, URL,
+ *                       or any other string that requires a trailing slash for proper formatting or usage.
  *
- * @param string
- * @return string
+ * @return string The modified string with a single trailing slash appended at the end. If the input string already
+ *                has one or more trailing slashes, they will be trimmed to a single slash.
+ *
+ * @uses rtrim() to remove any existing trailing slashes from the input string before appending a new trailing slash.
+ *      This ensures that the result consistently has exactly one trailing slash, regardless of the input string's initial state.
  */
 function trailingslashit( $string ) {
 	return rtrim( $string, '/' ) . '/';
 }
 
 /**
- * Process JUnit test results and return JSON. The resulting JSON will only
- * include failures.
+ * Parses JUnit XML formatted string to extract test results, focusing specifically on test failures and errors.
+ * The function converts the XML data into a structured JSON format that summarizes the overall test outcomes,
+ * including the total number of tests, failures, errors, and execution time. Only test suites and cases that
+ * contain failures or errors are included in the final JSON output. This function is useful for automated test
+ * result analysis, continuous integration reporting, or any scenario where a quick summary of test failures and
+ * errors is needed.
+ *
+ * @param string $xml_string The JUnit XML data as a string. This should be well-formed XML representing the results
+ *                           of test executions, typically generated by testing frameworks compatible with JUnit reporting.
  *
- * @param  string $xml String containing JUnit results.
- * @return string
+ * @return string A JSON encoded string that represents a summary of the test results, including overall metrics and
+ *                detailed information about each failed or errored test case. The JSON structure will include keys
+ *                for 'tests', 'failures', 'errors', 'time', and 'testsuites', where 'testsuites' is an array of test
+ *                suites that contains the failures or errors.
+ *
+ * @uses simplexml_load_string() to parse the JUnit XML data into an object for easy access and manipulation of the XML elements.
+ * @uses xpath() to query specific elements within the XML structure, particularly to find test suites with failures or errors.
+ * @uses json_encode() to convert the array structure containing the test results into a JSON formatted string.
  */
 function process_junit_xml( $xml_string )
 {
@@ -138,14 +203,26 @@ function process_junit_xml( $xml_string )
 }
 
 /**
- * Upload the results to the reporting API.
- *
- * @param  string $content The processed JUnit XML.
- * @param  string $rev     The SVN revision.
- * @param  string $message The SVN message.
- * @param  string $env     The environment data in JSON format
- * @param  string $api_key The API key for the reporting API.
- * @return array           Response from the reporting API.
+ * Submits test results along with associated metadata to a specified reporting API. The function constructs
+ * a POST request containing the test results, SVN revision, SVN message, environment data, and uses an API key
+ * for authentication. The reporting API's URL is retrieved from an environment variable; if not found, a default
+ * URL is used. This function is typically used to automate the reporting of test outcomes to a centralized system
+ * for analysis, tracking, and historical record-keeping.
+ *
+ * @param string $results The test results in a processed format (e.g., JSON) ready for submission to the reporting API.
+ * @param string $rev     The SVN revision associated with the test results. This often corresponds to a specific code
+ *                        commit or build identifier.
+ * @param string $message The SVN commit message associated with the revision, providing context or notes about the changes.
+ * @param string $env     The environment data in JSON format, detailing the conditions under which the tests were run,
+ *                        such as operating system, PHP version, etc.
+ * @param string $api_key The API key for authenticating with the reporting API, ensuring secure and authorized access.
+ *
+ * @return array An array containing two elements: the HTTP status code of the response (int) and the body of the response
+ *               (string) from the reporting API. This can be used to verify successful submission or to handle errors.
+ *
+ * @uses curl_init(), curl_setopt(), and curl_exec() to perform the HTTP POST request to the reporting API.
+ * @uses json_encode() to encode the data payload as a JSON string for submission.
+ * @uses base64_encode() to encode the API key for HTTP Basic Authentication in the Authorization header.
  */
 function upload_results( $results, $rev, $message, $env, $api_key ) {
 	$WPT_REPORT_URL = getenv( 'WPT_REPORT_URL' );
@@ -181,31 +258,76 @@ function upload_results( $results, $rev, $message, $env, $api_key ) {
 }
 
 /**
- * Get the environmental details
+ * Collects and returns an array of key environment details relevant to the application's context. This includes
+ * the PHP version, installed PHP modules with their versions, system utilities like curl and OpenSSL versions,
+ * MySQL version, and operating system details. This function is useful for diagnostic purposes, ensuring
+ * compatibility, or for reporting system configurations in debugging or error logs.
+ *
+ * The function checks for the availability of specific PHP modules and system utilities and captures their versions.
+ * It uses shell commands to retrieve system information, which requires the PHP environment to have access to these
+ * commands and appropriate permissions.
+ *
+ * @return array An associative array containing detailed environment information. The array includes:
+ *               - 'php_version': The current PHP version.
+ *               - 'php_modules': An associative array of selected PHP modules and their versions.
+ *               - 'system_utils': Versions of certain system utilities such as 'curl', 'imagemagick', 'graphicsmagick', and 'openssl'.
+ *               - 'mysql_version': The version of MySQL installed.
+ *               - 'os_name': The name of the operating system.
+ *               - 'os_version': The version of the operating system.
+ *
+ * @uses phpversion() to get the PHP version and module versions.
+ * @uses shell_exec() to execute system commands for retrieving MySQL version, OS details, and versions of utilities like curl and OpenSSL.
+ * @uses class_exists() to check for the availability of the Imagick and Gmagick classes for version detection.
  */
 function get_env_details() {
+	$WPT_DB_HOST = getenv( 'WPT_DB_HOST' ) ? : 'localhost';
+	$WPT_DB_USER = getenv( 'WPT_DB_USER' );
+	$WPT_DB_PASSWORD = getenv( 'WPT_DB_PASSWORD' );
+	$WPT_DB_NAME = getenv( 'WPT_DB_NAME' );
 	$env = array(
 		'php_version'    => phpversion(),
 		'php_modules'    => array(),
+		'gd_info'        => extension_loaded( 'gd' ) ? gd_info() : array(),
+		'imagick_info'   => extension_loaded( 'imagick' ) ? Imagick::queryFormats() : array(),
 		'system_utils'   => array(),
-		'mysql_version'  => trim( shell_exec( 'mysql --version' ) ),
 		'os_name'        => trim( shell_exec( 'uname -s' ) ),
 		'os_version'     => trim( shell_exec( 'uname -r' ) ),
 	);
 	$php_modules = array(
 		'bcmath',
+		'ctype',
 		'curl',
+		'date',
+		'dom',
+		'exif',
+		'fileinfo',
 		'filter',
+		'ftp',
 		'gd',
+		'gettext',
+		'gmagick',
+		'hash',
+		'iconv',
+		'imagick',
+		'imap',
+		'intl',
+		'json',
 		'libsodium',
+		'libxml',
+		'mbstring',
 		'mcrypt',
 		'mod_xml',
 		'mysqli',
-		'imagick',
-		'gmagick',
+		'mysqlnd',
+		'openssl',
 		'pcre',
+		'pdo_mysql',
+		'soap',
+		'sockets',
+		'sodium',
 		'xml',
 		'xmlreader',
+		'zip',
 		'zlib',
 	);
 	foreach( $php_modules as $php_module ) {
@@ -214,6 +336,10 @@ function get_env_details() {
 	function curl_selected_bits($k) { return in_array($k, array('version', 'ssl_version', 'libz_version')); }
 	$curl_bits = curl_version();
 	$env['system_utils']['curl'] = implode(' ',array_values(array_filter($curl_bits, 'curl_selected_bits',ARRAY_FILTER_USE_KEY) ));
+	$mysqli = new mysqli($WPT_DB_HOST, $WPT_DB_USER, $WPT_DB_PASSWORD, $WPT_DB_NAME);
+	$env['mysql_version'] = $mysqli->query("SELECT VERSION()")->fetch_row()[0];
+	$mysqli->close();
+
 	if ( class_exists( 'Imagick' ) ) {
 		$imagick = new Imagick();
 		$version = $imagick->getVersion();
diff --git a/prepare.php b/prepare.php
index a572b51..52b5aa1 100644
--- a/prepare.php
+++ b/prepare.php
@@ -1,49 +1,154 @@
 <?php
-
 /**
- * Prepares the environment for the test run.
+ * This script prepares the environment for WordPress unit tests.
+ * It sets up the necessary variables and configurations based on the environment.
+ * The script assumes that certain environment variables are set to configure SSH,
+ * directories, and executables used in the test preparation process.
+ *
+ * @link https://github.com/wordpress/phpunit-test-runner/ Original source repository
+ * @package WordPress
  */
-
 require __DIR__ . '/functions.php';
 
-// Check required environment variables.
+/**
+ * Check for the presence of required environment variables.
+ * This function should be defined in functions.php and should throw an
+ * exception or exit if any required variables are missing.
+ */
 check_required_env();
 
-// Bring some environment variables into scope.
-$WPT_PREPARE_DIR = getenv( 'WPT_PREPARE_DIR' );
-$WPT_SSH_CONNECT = getenv( 'WPT_SSH_CONNECT' );
-$WPT_SSH_OPTIONS = getenv( 'WPT_SSH_OPTIONS' ) ? : '-o StrictHostKeyChecking=no';
-$WPT_TEST_DIR = getenv( 'WPT_TEST_DIR' );
-$WPT_PHP_EXECUTABLE = getenv( 'WPT_PHP_EXECUTABLE' ) ? : 'php';
-$WPT_DEBUG = getenv( 'WPT_DEBUG' );
+/**
+ * Retrieves environment variables and sets defaults for test preparation.
+ * These variables are used to configure SSH connections, file paths, and
+ * executable commands needed for setting up the test environment.
+ */
+$WPT_PREPARE_DIR    = trim( getenv( 'WPT_PREPARE_DIR' ) );
+$WPT_SSH_CONNECT    = trim( getenv( 'WPT_SSH_CONNECT' ) );
+$WPT_SSH_OPTIONS    = trim( getenv( 'WPT_SSH_OPTIONS' ) ) ? : '-o StrictHostKeyChecking=no';
+$WPT_TEST_DIR       = trim( getenv( 'WPT_TEST_DIR' ) );
+$WPT_PHP_EXECUTABLE = trim( getenv( 'WPT_PHP_EXECUTABLE' ) ) ? : 'php';
+$WPT_CERTIFICATE_VALIDATION = trim( getenv( 'WPT_CERTIFICATE_VALIDATION' ) );
+
+/**
+ * Determines if the debug mode is enabled based on the 'WPT_DEBUG' environment variable.
+ * The debug mode can affect error reporting and other debug-related settings.
+ */
+$WPT_DEBUG_INI = getenv( 'WPT_DEBUG' );
+switch( $WPT_DEBUG_INI ) {
+	case 0:
+	case 'false':
+		$WPT_DEBUG = false;
+		break;
+	case 1:
+	case 'true':
+	case 'verbose':
+		$WPT_DEBUG = 'verbose';
+		break;
+	default:
+		$WPT_DEBUG = false;
+		break;
+}
+unset( $WPT_DEBUG_INI );
+
+/**
+ * Sets up the SSH private key for use in the test environment if provided.
+ * The private key is expected to be in base64-encoded form in the environment variable 'WPT_SSH_PRIVATE_KEY_BASE64'.
+ * It is decoded and saved to the user's .ssh directory as 'id_rsa'.
+ * Proper permissions are set on the private key to secure it.
+ * If an SSH connection string is provided, it performs a remote operation to ensure the WP CLI is accessible.
+ * Otherwise, it performs a local operation to check the WP CLI.
+ *
+ * @throws Exception If there is an issue creating the .ssh directory or writing the key file.
+ */
+// Set the SSH private key if it's provided in the environment.
+$WPT_SSH_PRIVATE_KEY_BASE64 = trim( getenv( 'WPT_SSH_PRIVATE_KEY_BASE64' ) );
 
-// Set the ssh private key if it's set.
-$WPT_SSH_PRIVATE_KEY_BASE64 = getenv( 'WPT_SSH_PRIVATE_KEY_BASE64' );
+// Check if the private key variable is not empty.
 if ( ! empty( $WPT_SSH_PRIVATE_KEY_BASE64 ) ) {
+
+	// Log the action of securely extracting the private key.
 	log_message( 'Securely extracting WPT_SSH_PRIVATE_KEY_BASE64 into ~/.ssh/id_rsa' );
+
+	// Check if the .ssh directory exists in the home directory, and create it if it does not.
 	if ( ! is_dir( getenv( 'HOME' ) . '/.ssh' ) ) {
+		// The mkdir function creates the directory with the specified permissions and the recursive flag set to true.
 		mkdir( getenv( 'HOME' ) . '/.ssh', 0777, true );
 	}
+
+	// Write the decoded private key into the id_rsa file within the .ssh directory.
 	file_put_contents( getenv( 'HOME' ) . '/.ssh/id_rsa', base64_decode( $WPT_SSH_PRIVATE_KEY_BASE64 ) );
-	perform_operations( array(
-		'chmod 600 ~/.ssh/id_rsa',
-		'ssh -q ' . $WPT_SSH_OPTIONS . ' ' . escapeshellarg( $WPT_SSH_CONNECT ) . ' wp cli info',
-	) );
+
+	// Define the array of operations to perform, depending on the SSH connection availability.
+	// If no SSH connection string is provided, add a local operation to the array.
+	// If an SSH connection string is provided, add a remote operation to the array.
+	// Execute the operations defined in the operations array.
+	if( empty( $WPT_SSH_CONNECT ) ) {
+		perform_operations( array(
+			'chmod 600 ~/.ssh/id_rsa',
+			'wp cli info'
+		) );
+	} else {
+		perform_operations( array(
+			'chmod 600 ~/.ssh/id_rsa',
+			'ssh -q ' . $WPT_SSH_OPTIONS . ' ' . escapeshellarg( $WPT_SSH_CONNECT ) . ' wp cli info'
+		) );
+	}
+
 }
 
-// Create the preparation directory and fetch corresponding files
+/**
+ * Don't validate the TLS certificate
+ * Useful for local environments
+ */
+$certificate_validation = '';
+if( ! $WPT_CERTIFICATE_VALIDATION ) {
+	$certificate_validation .= ' --no-check-certificate';
+}
+
+/**
+ * Performs a series of operations to set up the test environment. This includes creating a preparation directory,
+ * cloning the WordPress development repository, downloading the WordPress importer plugin, and preparing the environment with npm.
+ */
+// Prepare an array of shell commands to set up the testing environment.
 perform_operations( array(
+
+	// Create the preparation directory if it doesn't exist. The '-p' flag creates intermediate directories as required.
 	'mkdir -p ' . escapeshellarg( $WPT_PREPARE_DIR ),
+
+	// Clone the WordPress develop repository from GitHub into the preparation directory.
+	// The '--depth=1' flag creates a shallow clone with a history truncated to the last commit.
 	'git clone --depth=1 https://github.com/WordPress/wordpress-develop.git ' . escapeshellarg( $WPT_PREPARE_DIR ),
-	'wget -O ' . escapeshellarg( $WPT_PREPARE_DIR . '/tests/phpunit/data/plugins/wordpress-importer.zip' ) . ' https://downloads.wordpress.org/plugin/wordpress-importer.zip',
+
+	// Download the WordPress importer plugin zip file to the specified plugins directory.
+	'wget -O ' . escapeshellarg( $WPT_PREPARE_DIR . '/tests/phpunit/data/plugins/wordpress-importer.zip' ) . ' https://downloads.wordpress.org/plugin/wordpress-importer.zip' . $certificate_validation,
+
+	// Change directory to the plugin directory, unzip the WordPress importer plugin, and remove the zip file.
 	'cd ' . escapeshellarg( $WPT_PREPARE_DIR . '/tests/phpunit/data/plugins/' ) . '; unzip wordpress-importer.zip; rm wordpress-importer.zip',
-	'cd ' . escapeshellarg( $WPT_PREPARE_DIR ) . '; npm install && npm run build',
+
+	// Change directory to the preparation directory, install npm dependencies, and build the project.
+	'cd ' . escapeshellarg( $WPT_PREPARE_DIR ) . '; npm install && npm run build'
+
 ) );
 
-// Replace variables in the wp-config.php file.
+// Log a message indicating the start of the variable replacement process for configuration.
 log_message( 'Replacing variables in wp-tests-config.php' );
+
+/**
+ * Reads the contents of the WordPress test configuration sample file.
+ * This file contains template placeholders that need to be replaced with actual values 
+ * from environment variables to configure the WordPress test environment.
+ */
 $contents = file_get_contents( $WPT_PREPARE_DIR . '/wp-tests-config-sample.php' );
-// Log system information to same directory as test run log.
+
+/**
+ * Prepares a script to log system information relevant to the testing environment.
+ * The script checks for the existence of the log directory and creates it if it does not exist.
+ * It then collects various pieces of system information including PHP version, loaded PHP modules,
+ * MySQL version, operating system details, and versions of key utilities like cURL and OpenSSL.
+ * This information is collected in an array and written to a JSON file in the log directory.
+ * Additionally, if running from the command line during a WordPress installation process, 
+ * it outputs the PHP version and executable path.
+ */
 $system_logger = <<<EOT
 // Create the log directory to store test results
 if ( ! is_dir(  __DIR__ . '/tests/phpunit/build/logs/' ) ) {
@@ -53,25 +158,47 @@
 \$env = array(
 	'php_version'    => phpversion(),
 	'php_modules'    => array(),
+	'gd_info'        => extension_loaded( 'gd' ) ? gd_info() : array(),
+	'imagick_info'   => extension_loaded( 'imagick' ) ? Imagick::queryFormats() : array(),
 	'system_utils'   => array(),
-	'mysql_version'  => trim( shell_exec( 'mysql --version' ) ),
 	'os_name'        => trim( shell_exec( 'uname -s' ) ),
 	'os_version'     => trim( shell_exec( 'uname -r' ) ),
 );
 \$php_modules = array(
 	'bcmath',
+	'ctype',
 	'curl',
+	'date',
+	'dom',
+	'exif',
+	'fileinfo',
 	'filter',
+	'ftp',
 	'gd',
+	'gettext',
+	'gmagick',
+	'hash',
+	'iconv',
+	'imagick',
+	'imap',
+	'intl',
+	'json',
 	'libsodium',
+	'libxml',
+	'mbstring',
 	'mcrypt',
 	'mod_xml',
 	'mysqli',
-	'imagick',
-	'gmagick',
+	'mysqlnd',
+	'openssl',
 	'pcre',
+	'pdo_mysql',
+	'soap',
+	'sockets',
+	'sodium',
 	'xml',
 	'xmlreader',
+	'zip',
 	'zlib',
 );
 foreach( \$php_modules as \$php_module ) {
@@ -92,6 +219,10 @@ function curl_selected_bits(\$k) { return in_array(\$k, array('version', 'ssl_ve
 	\$env['system_utils']['graphicsmagick'] = \$version[1];
 }
 \$env['system_utils']['openssl'] = str_replace( 'OpenSSL ', '', trim( shell_exec( 'openssl version' ) ) );
+
+\$mysqli = new mysqli(DB_HOST, DB_USER, DB_PASSWORD, DB_NAME);
+\$env['mysql_version'] = \$mysqli->query("SELECT VERSION()")->fetch_row()[0];
+\$mysqli->close();
 file_put_contents( __DIR__ . '/tests/phpunit/build/logs/env.json', json_encode( \$env, JSON_PRETTY_PRINT ) );
 if ( 'cli' === php_sapi_name() && defined( 'WP_INSTALLING' ) && WP_INSTALLING ) {
 	echo PHP_EOL;
@@ -99,88 +230,136 @@ function curl_selected_bits(\$k) { return in_array(\$k, array('version', 'ssl_ve
 	echo PHP_EOL;
 }
 EOT;
+
+// Initialize a string that will be used to identify the database settings section in the configuration file.
 $logger_replace_string = '// ** Database settings ** //' . PHP_EOL;
+
+// Prepend the logger script to the database settings identifier to ensure it gets included in the wp-tests-config.php file.
 $system_logger = $logger_replace_string . $system_logger;
+
+// Define a string that will set the 'WP_PHP_BINARY' constant to the path of the PHP executable.
 $php_binary_string = 'define( \'WP_PHP_BINARY\', \''. $WPT_PHP_EXECUTABLE . '\' );';
+
+/**
+ * An associative array mapping configuration file placeholders to environment-specific values.
+ * This array is used in the subsequent str_replace operation to replace placeholders
+ * in the wp-tests-config-sample.php file with values from the environment or defaults if none are provided.
+ */
 $search_replace = array(
-	'wptests_'                              => getenv( 'WPT_TABLE_PREFIX' ) ? : 'wptests_',
-	'youremptytestdbnamehere'               => getenv( 'WPT_DB_NAME' ),
-	'yourusernamehere'                      => getenv( 'WPT_DB_USER' ),
-	'yourpasswordhere'                      => getenv( 'WPT_DB_PASSWORD' ),
-	'localhost'                             => getenv( 'WPT_DB_HOST' ),
+	'wptests_'                              => trim( getenv( 'WPT_TABLE_PREFIX' ) ) ? : 'wptests_',
+	'youremptytestdbnamehere'               => trim( getenv( 'WPT_DB_NAME' ) ),
+	'yourusernamehere'                      => trim( getenv( 'WPT_DB_USER' ) ),
+	'yourpasswordhere'                      => trim( getenv( 'WPT_DB_PASSWORD' ) ),
+	'localhost'                             => trim( getenv( 'WPT_DB_HOST' ) ),
 	'define( \'WP_PHP_BINARY\', \'php\' );' => $php_binary_string,
 	$logger_replace_string                  => $system_logger,
 );
+
+// Replace the placeholders in the wp-tests-config-sample.php file content with actual values.
 $contents = str_replace( array_keys( $search_replace ), array_values( $search_replace ), $contents );
+
+// Write the modified content to the wp-tests-config.php file, which will be used by the test suite.
 file_put_contents( $WPT_PREPARE_DIR . '/wp-tests-config.php', $contents );
 
-// Now, install PHPUnit based on the test environment's PHP Version
+/**
+ * Determines the PHP version of the test environment to ensure the correct version of PHPUnit is installed.
+ * It constructs a command that prints out the PHP version in a format compatible with PHPUnit's version requirements.
+ */
 $php_version_cmd = $WPT_PHP_EXECUTABLE . " -r \"print PHP_MAJOR_VERSION . '.' . PHP_MINOR_VERSION . '.' . PHP_RELEASE_VERSION;\"";
+
+/**
+ * If an SSH connection string is provided, the command to determine the PHP version is modified 
+ * to execute remotely over SSH. This is required if the test environment is not the local machine.
+ */
 if ( ! empty( $WPT_SSH_CONNECT ) ) {
+	// The PHP version check command is prefixed with the SSH command, including SSH options,
+	// and the connection string, ensuring the command is executed on the remote machine.
 	$php_version_cmd = 'ssh ' . $WPT_SSH_OPTIONS . ' ' . escapeshellarg( $WPT_SSH_CONNECT ) . ' ' . escapeshellarg( $php_version_cmd );
 }
 
+// Initialize return value variable for the exec function call.
 $retval = 0;
+
+/**
+ * Executes the constructed command to obtain the PHP version of the test environment.
+ * The output is stored in $env_php_version, and the return value of the command execution is stored in $retval.
+ */
 $env_php_version = exec( $php_version_cmd, $output, $retval );
+
+// Check if the command execution was successful by inspecting the return value.
 if ( $retval !== 0 ) {
+	// If the return value is not zero, an error occurred, and a message is logged.
 	error_message( 'Could not retrieve the environment PHP Version.' );
 }
-log_message( "Environment PHP Version: $env_php_version" );
 
-// If PHP Version is 8.X.X, set PHP Version to 7.4 for compatibility with core PHPUnit tests.
-if ( substr( $env_php_version, 0 , 2 ) === '8.' ) {
-	log_message( 'Version 8.x.x Found. Downloading PHPUnit for PHP 7.4 instead for compatibility.' );
-	$env_php_version = '7.4';
-}
+// Log the obtained PHP version for confirmation and debugging purposes.
+log_message( 'Environment PHP Version: ' . $env_php_version );
 
-if ( version_compare( $env_php_version, '5.6', '<' ) ) {
-	error_message( "The test runner is not compatible with PHP < 5.6." );
+/**
+ * Checks if the detected PHP version is below 7.0.
+ * The test runner requires PHP version 7.0 or above, and if the environment's PHP version
+ * is lower, it logs an error message and could terminate the script.
+ */
+if ( version_compare( $env_php_version, '7.0', '<' ) ) {
+	// Logs an error message indicating the test runner's incompatibility with PHP versions below 7.0.
+	error_message( 'The test runner is not compatible with PHP < 7.0.' );
 }
 
-// If PHP version is 5.6-7.0, download PHPUnit 5.7 phar directly.
-if ( version_compare( $env_php_version, '7.1', '<' ) ) {
-	perform_operations( array(
-		'wget -O ' .  escapeshellarg( $WPT_PREPARE_DIR . '/phpunit.phar' ) . ' https://phar.phpunit.de/phpunit-5.7.phar',
-	) );
+/**
+ * Use Composer to manage PHPUnit and its dependencies.
+ * This allows for better dependency management and compatibility.
+ */
 
-// Otherwise, use Composer to download PHPUnit to get further necessary dependencies.
-} else {
+// Check if Composer is installed and available in the PATH.
+$composer_cmd = 'cd ' . escapeshellarg( $WPT_PREPARE_DIR ) . ' && ';
+$retval = 0;
+$composer_path = escapeshellarg( system( 'which composer', $retval ) );
 
-	// First, check if composer is available. Download if not.
-	$composer_cmd = 'cd ' . escapeshellarg( $WPT_PREPARE_DIR ) . ' && ';
+if ( $retval === 0 ) {
 
-	$retval = 0;
-	$composer_path = escapeshellarg( system( 'which composer', $retval ) );
-	if ( $retval === 0 ) {
-		$composer_cmd .= $composer_path . ' ';
-	} else {
-		log_message( 'Local Composer not found. Downloading latest stable ...' );
+	// If Composer is available, prepare the command to use the Composer binary.
+	$composer_cmd .= $composer_path . ' ';
 
-		perform_operations( array(
-			'wget -O ' . escapeshellarg( $WPT_PREPARE_DIR . '/composer.phar' ) . ' https://getcomposer.org/composer-stable.phar',
-		) );
+} else {
 
-		$composer_cmd .= 'php composer.phar ';
-	}
+	// If Composer is not available, download the Composer phar file.
+	log_message( 'Local Composer not found. Downloading latest stable ...' );
 
-	// Set Composer PHP environment, then run Composer.
 	perform_operations( array(
-		$composer_cmd . 'config platform.php ' . escapeshellarg( $env_php_version ),
-		$composer_cmd . 'update',
+		'wget -O ' . escapeshellarg( $WPT_PREPARE_DIR . '/composer.phar' ) . ' https://getcomposer.org/composer-stable.phar',
 	) );
+
+	// Update the command to use the downloaded Composer phar file.
+	$composer_cmd .= 'php composer.phar ';
 }
 
-// Deliver all files to test environment.
+// Set the PHP version for Composer to ensure compatibility and update dependencies.
+perform_operations( array(
+	$composer_cmd . 'config platform.php ' . escapeshellarg( $env_php_version ),
+	$composer_cmd . 'update',
+) );
+
+/**
+ * If an SSH connection is configured, use rsync to transfer the prepared files to the remote test environment.
+ * The -r option for rsync enables recursive copying to handle directory structures.
+ * Additional rsync options may be included for more verbose output if debugging is enabled.
+ */
 if ( ! empty( $WPT_SSH_CONNECT ) ) {
+	// Initialize rsync options with recursive copying.
 	$rsync_options = '-r';
 
+	// If debug mode is set to verbose, append 'v' to rsync options for verbose output.
 	if ( 'verbose' === $WPT_DEBUG ) {
 		$rsync_options = $rsync_options . 'v';
 	}
 
+	// Perform the rsync operation with the configured options and exclude patterns.
+	// This operation synchronizes the test environment with the prepared files, excluding version control directories
+	// and other non-essential files for test execution.
 	perform_operations( array(
 		'rsync ' . $rsync_options . ' --exclude=".git/" --exclude="node_modules/" --exclude="composer.phar" -e "ssh ' . $WPT_SSH_OPTIONS . '" ' . escapeshellarg( trailingslashit( $WPT_PREPARE_DIR )  ) . ' ' . escapeshellarg( $WPT_SSH_CONNECT . ':' . $WPT_TEST_DIR ),
 	) );
 }
 
+// Log a success message indicating that the environment has been prepared.
 log_message( 'Success: Prepared environment.' );
diff --git a/report.php b/report.php
index 7384886..b690f76 100644
--- a/report.php
+++ b/report.php
@@ -1,50 +1,136 @@
 <?php
-
 /**
- * Reports the test run results to WordPress.org
+ * This script is responsible for reporting the results of the PHPUnit test runs to WordPress.org.
+ * It gathers necessary information such as the SVN revision, test run messages, and the junit.xml
+ * file containing the results. It then uploads these details using the WordPress.org API if an API
+ * key is provided, or logs the results for later use.
+ *
+ * @link https://github.com/wordpress/phpunit-test-runner/ Original source repository
+ * @package WordPress
  */
-
 require __DIR__ . '/functions.php';
 
-// Check required environment variables.
+/**
+ * Check for the presence of required environment variables.
+ * This function should be defined in functions.php and should throw an
+ * exception or exit if any required variables are missing.
+ */
 check_required_env( false );
 
-$WPT_SSH_CONNECT = getenv( 'WPT_SSH_CONNECT' );
-$WPT_TEST_DIR = getenv( 'WPT_TEST_DIR' );
-$WPT_PREPARE_DIR = getenv( 'WPT_PREPARE_DIR' );
-$WPT_SSH_OPTIONS = getenv( 'WPT_SSH_OPTIONS' );
-$WPT_REPORT_API_KEY = getenv( 'WPT_REPORT_API_KEY' );
-$WPT_DEBUG = getenv( 'WPT_DEBUG' );
+/**
+ * Retrieves environment variables and sets defaults for test preparation.
+ * These variables are used to configure SSH connections, file paths, and
+ * executable commands needed for setting up the test environment.
+ */
+$WPT_SSH_CONNECT    = trim( getenv( 'WPT_SSH_CONNECT' ) );
+$WPT_TEST_DIR       = trim( getenv( 'WPT_TEST_DIR' ) );
+$WPT_PREPARE_DIR    = trim( getenv( 'WPT_PREPARE_DIR' ) );
+$WPT_SSH_OPTIONS    = trim( getenv( 'WPT_SSH_OPTIONS' ) );
+$WPT_REPORT_API_KEY = trim( getenv( 'WPT_REPORT_API_KEY' ) );
+
+/**
+ * Determines if the debug mode is enabled based on the 'WPT_DEBUG' environment variable.
+ * The debug mode can affect error reporting and other debug-related settings.
+ */
+$WPT_DEBUG_INI = getenv( 'WPT_DEBUG' );
+switch( $WPT_DEBUG_INI ) {
+	case 0:
+	case 'false':
+		$WPT_DEBUG = false;
+		break;
+	case 1:
+	case 'true':
+	case 'verbose':
+		$WPT_DEBUG = 'verbose';
+		break;
+	default:
+		$WPT_DEBUG = false;
+		break;
+}
+unset( $WPT_DEBUG_INI );
 
+/**
+ * Retrieves the SVN revision number from the git repository log.
+ * Logs a message indicating the start of the SVN revision retrieval process.
+ * Executes a shell command that accesses the git directory specified by the
+ * WPT_PREPARE_DIR environment variable, retrieves the latest commit message,
+ * and extracts the SVN revision number using a combination of grep and cut commands.
+ */
 log_message('Getting SVN Revision');
 $rev = exec('git --git-dir=' . escapeshellarg( $WPT_PREPARE_DIR ) . '/.git log -1 --pretty=%B | grep "git-svn-id:" | cut -d " " -f 2 | cut -d "@" -f 2');
 
+/**
+ * Retrieves the latest SVN commit message from the git repository log.
+ * Logs a message to indicate the retrieval of the SVN commit message. Executes a shell command
+ * that accesses the git directory specified by the WPT_PREPARE_DIR environment variable,
+ * fetches the latest commit message, and trims any whitespace from the message.
+ */
 log_message('Getting SVN message');
 $message = trim( exec('git --git-dir=' . escapeshellarg( $WPT_PREPARE_DIR ) . '/.git log -1 --pretty=%B | head -1') );
 
+/**
+ * Prepares the file path for copying the junit.xml results.
+ * Logs a message indicating the start of the operation to copy junit.xml results.
+ * Constructs the file path to the junit.xml file(s) located in the test directory,
+ * making use of the WPT_TEST_DIR environment variable. The path is sanitized to be
+ * safely used in shell commands.
+ */
 log_message('Copying junit.xml results');
 $junit_location = escapeshellarg( $WPT_TEST_DIR ) . '/tests/phpunit/build/logs/*';
 
+/**
+ * Modifies the junit.xml results file path for a remote location if an SSH connection is available.
+ * If the WPT_SSH_CONNECT environment variable is not empty, indicating that an SSH connection
+ * is configured, this snippet adapts the junit_location variable to include the necessary SSH
+ * command and options for accessing the remote file system. It concatenates SSH options with the
+ * remote path to ensure that the junit.xml results can be accessed or copied over SSH.
+ */
 if ( ! empty( $WPT_SSH_CONNECT ) ) {
 	$junit_location = '-e "ssh ' . $WPT_SSH_OPTIONS . '" ' . escapeshellarg( $WPT_SSH_CONNECT . ':' . $junit_location );
 }
 
+/**
+ * Sets the options for the rsync command based on the debug mode.
+ * Initializes the rsync options with the recursive flag. If the debug mode is set to 'verbose',
+ * appends the 'v' flag to the rsync options to enable verbose output during the rsync operation,
+ * providing more detailed information about the file transfer process.
+ */
 $rsync_options = '-r';
 
 if ( 'verbose' === $WPT_DEBUG ) {
 	$rsync_options = $rsync_options . 'v';
 }
 
+/**
+ * Constructs the rsync command for executing the synchronization of junit.xml files.
+ * Concatenates the rsync command with the previously defined options and the source and
+ * destination paths. The destination path is sanitized for shell execution. This command is
+ * then passed to the `perform_operations` function, which executes the command to synchronize
+ * the junit.xml files from the source to the destination directory.
+ */
 $junit_exec = 'rsync ' . $rsync_options . ' ' . $junit_location . ' ' . escapeshellarg( $WPT_PREPARE_DIR );
 perform_operations( array(
 	$junit_exec,
 ) );
 
+/**
+ * Processes and uploads the junit.xml file.
+ * First, a log message is recorded to indicate the start of processing the junit.xml file.
+ * Then, the contents of the junit.xml file are read from the prepared directory into a string.
+ * This XML string is then passed to a function that processes the XML data, presumably to prepare
+ * it for upload or to extract relevant test run information.
+ */
 log_message( 'Processing and uploading junit.xml' );
-
 $xml = file_get_contents( $WPT_PREPARE_DIR . '/junit.xml' );
 $results = process_junit_xml( $xml );
 
+/**
+ * Retrieves environment details from a JSON file or generates them if not available.
+ * Initializes the environment details string. If an 'env.json' file exists in the prepared
+ * directory, its contents are read into the environment details string. If the file doesn't
+ * exist but the prepared directory is the same as the test directory, the environment details
+ * are generated by calling a function that retrieves these details, then encoded into JSON format.
+ */
 $env = '';
 if ( file_exists( $WPT_PREPARE_DIR . '/env.json' ) ) {
 	$env = file_get_contents( $WPT_PREPARE_DIR . '/env.json' );
@@ -52,16 +138,42 @@
 	$env = json_encode( get_env_details(), JSON_PRETTY_PRINT );
 }
 
-list( $http_status, $response_body ) = upload_results( $results, $rev, $message, $env, $WPT_REPORT_API_KEY );
+/**
+ * Attempts to upload test results if an API key is available, otherwise logs the results locally.
+ * Checks if an API key for reporting is present. If so, it attempts to upload the test results
+ * using the `upload_results` function and processes the HTTP response. A success message is logged
+ * if the upload is successful, indicated by a 20x HTTP status code. If the upload fails, an error
+ * message is logged along with the HTTP status. If no API key is provided, it logs the test results
+ * and environment details locally.
+ */
+if( ! empty( $WPT_REPORT_API_KEY ) ) {
+
+	// Upload the results and capture the HTTP status and response body
+	list( $http_status, $response_body ) = upload_results( $results, $rev, $message, $env, $WPT_REPORT_API_KEY );
+
+	// Decode the JSON response body
+	$response = json_decode( $response_body, true );
+	if ( 20 == substr( $http_status, 0, 2 ) ) {
+
+		// Construct and log a success message with a link if provided in the response
+		$message = 'Results successfully uploaded';
+		$message .= isset( $response['link'] ) ? ': ' . $response['link'] : '';
+		log_message( $message );
+
+	} else {
+
+		// Construct and log an error message with additional details if provided in the response
+		$message = 'Error uploading results';
+		$message .= isset( $response['message'] ) ? ': ' . $response['message'] : '';
+		$message .= ' (HTTP status ' . (int) $http_status . ')';
+		error_message( $message );
+
+	}
 
-$response = json_decode( $response_body, true );
-if ( 20 == substr( $http_status, 0, 2 ) ) {
-	$message = 'Results successfully uploaded';
-	$message .= isset( $response['link'] ) ? ': ' . $response['link'] : '';
-	log_message( $message );
 } else {
-	$message = 'Error uploading results';
-	$message .= isset( $response['message'] ) ? ': ' . $response['message'] : '';
-	$message .= ' (HTTP status ' . (int) $http_status . ')';
-	error_message( $message );
+
+	// Log the test results and environment details locally if no API key is provided
+	log_message( '[+] TEST RESULTS' . "\n\n" . $results. "\n\n" );
+	log_message( '[+] ENVIRONMENT' . "\n\n" . $env . "\n\n" );
+
 }
diff --git a/test.php b/test.php
index b4bff05..18b3f4f 100644
--- a/test.php
+++ b/test.php
@@ -1,26 +1,85 @@
 <?php
-
 /**
- * Runs the PHPUnit test suite in the test environment.
+ * Executes the PHPUnit test suite within the WordPress testing environment.
+ * This script is designed to run tests either locally or on a remote server based on the environment setup.
+ * It dynamically constructs the command to run PHPUnit and then executes it.
+ * 
+ * @link https://github.com/wordpress/phpunit-test-runner/ Original source repository
+ * @package WordPress
  */
-
 require __DIR__ . '/functions.php';
 
-// Check required environment variables.
+/**
+ * Check for the presence of required environment variables.
+ * This function should be defined in functions.php and should throw an
+ * exception or exit if any required variables are missing.
+ */
 check_required_env();
 
-$WPT_SSH_CONNECT = getenv( 'WPT_SSH_CONNECT' );
-$WPT_TEST_DIR = getenv( 'WPT_TEST_DIR' );
-$WPT_SSH_OPTIONS = getenv( 'WPT_SSH_OPTIONS' ) ? : '-o StrictHostKeyChecking=no';
-$WPT_PHP_EXECUTABLE = getenv( 'WPT_PHP_EXECUTABLE' ) ? : 'php';
+/**
+ * Retrieves environment variables and sets defaults for test preparation.
+ * These variables are used to configure SSH connections, file paths, and
+ * executable commands needed for setting up the test environment.
+ */
+$WPT_SSH_CONNECT    = trim( getenv( 'WPT_SSH_CONNECT' ) );
+$WPT_TEST_DIR       = trim( getenv( 'WPT_TEST_DIR' ) );
+$WPT_SSH_OPTIONS    = trim( getenv( 'WPT_SSH_OPTIONS' ) ) ? : '-o StrictHostKeyChecking=no';
+$WPT_PHP_EXECUTABLE = trim( getenv( 'WPT_PHP_EXECUTABLE' ) ) ? : 'php';
+
+// Uses the flavor (usually to test WordPress Multisite)
+$WPT_FLAVOR_INI = trim( getenv( 'WPT_FLAVOR' ) );
+switch( $WPT_FLAVOR_INI ) {
+	case 0:
+		$WPT_FLAVOR_TXT = ''; // Simple WordPress
+		break;
+	case 1:
+		$WPT_FLAVOR_TXT = ' -c tests/phpunit/multisite.xml'; // WordPress Multisite
+		break;
+	default:
+		$WPT_FLAVOR_TXT = '';
+		break;
+}
+unset( $WPT_FLAVOR_INI );
 
-// This uses `||` to run PHPUnit when it is downloaded manually (like for PHP 5.6-7.0) rather than through Composer.
-$WPT_PHPUNIT_CMD = getenv( 'WPT_PHPUNIT_CMD' ) ? : 'cd ' . escapeshellarg( $WPT_TEST_DIR ) . ' && ' . $WPT_PHP_EXECUTABLE . ' ./vendor/phpunit/phpunit/phpunit --dont-report-useless-tests || ' . $WPT_PHP_EXECUTABLE . ' phpunit.phar --dont-report-useless-tests';
+// Uses the flavor (usually to test WordPress Multisite)
+$WPT_EXTRATESTS_INI = trim( getenv( 'WPT_EXTRATESTS' ) );
+switch( $WPT_EXTRATESTS_INI ) {
+	case 0:
+		$WPT_EXTRATESTS_TXT = ''; // no extra tests
+		break;
+	case 1:
+		$WPT_EXTRATESTS_TXT = ' --group ajax'; // ajax tests
+		break;
+	case 2:
+		$WPT_EXTRATESTS_TXT = ' --group ms-files'; // ms-files tests
+		break;
+	case 3:
+		$WPT_EXTRATESTS_TXT = ' --group external-http'; // external-http tests
+		break;
+	default:
+		$WPT_EXTRATESTS_TXT = '';
+		break;
+}
+unset( $WPT_EXTRATESTS_INI );
 
-// Run phpunit in the test environment.
+/**
+ * Determines the PHPUnit command to execute the test suite.
+ * Retrieves the PHPUnit command from the environment variable 'WPT_PHPUNIT_CMD'. If the environment
+ * variable is not set or is empty, it constructs a default command using the PHP executable path and
+ * the test directory path from environment variables, appending parameters to the PHPUnit call to
+ * avoid reporting useless tests.
+ */
+$WPT_PHPUNIT_CMD = trim( getenv( 'WPT_PHPUNIT_CMD' ) );
+if( empty( $WPT_PHPUNIT_CMD ) ) {
+	$WPT_PHPUNIT_CMD = 'cd ' . escapeshellarg( $WPT_TEST_DIR ) . ' && ' . $WPT_PHP_EXECUTABLE . ' ./vendor/phpunit/phpunit/phpunit --dont-report-useless-tests' . $WPT_FLAVOR_TXT . $WPT_EXTRATESTS_TXT;
+}
+
+// If an SSH connection string is provided, prepend the SSH command to the PHPUnit execution command.
 if ( ! empty( $WPT_SSH_CONNECT ) ) {
 	$WPT_PHPUNIT_CMD = 'ssh ' . $WPT_SSH_OPTIONS . ' ' . escapeshellarg( $WPT_SSH_CONNECT ) . ' ' . escapeshellarg( $WPT_PHPUNIT_CMD );
 }
+
+// Execute the PHPUnit command.
 perform_operations( array(
-	$WPT_PHPUNIT_CMD,
+	$WPT_PHPUNIT_CMD
 ) );