Output formatting issue in PHPUnit with TestDox #5949

omegacms · 2024-09-12T12:02:50Z

I am facing an output formatting problem in my PHPUnit tests when I employ TestDox. Specifically, the final test method in each class is consistently displayed with improper spacing or indentation. This occurs regardless of the method's location within the class. I have attempted to rearrange the methods and even created new test classes, but the issue remains.

I've observed that the problem seems to be connected to the utilization of the #[Test] and #[TestDox] attributes, and the placement of comments within test methods. No matter how I position the attributes and comments, the last method is always formatted incorrectly.

I am using PHPUnit version 11.3.4. My code editor is Nano/Visual Studio Code/PHPStorm, on Linux system.

The phpunit.xml file is:

<?xml version="1.0" encoding="UTF-8"?> 
<phpunit 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="phpunit.xsd" 
    bootstrap="tests/bootstrap.php"
	cacheDirectory=".phpunit.cache/code-coverage"
	cacheResult="true"
    executionOrder="depends,defects"
	defaultTestSuite="OmegaCMS Test Suite"
    beStrictAboutOutputDuringTests="true"
    failOnRisky="true"
    failOnWarning="true"
	testdox="true"
	testdoxSummary="true"
	colors="true"
	>
 	<testsuites>
 		<testsuite name="OmegaCMS Test Suite">
      		<directory>tests</directory>
			<directory>vendor/omegacms/*/tests</directory>
      	</testsuite>
  	</testsuites>
	<source>
		<include>
			<directory suffix=".php">app</directory>
			<directory suffix=".php">vendor/omegacms/*/src</directory>
		</include>
	</source>
    <coverage 
		includeUncoveredFiles="true"
		pathCoverage="true"
		>
		<report>
    		<html outputDirectory="coverage-report" lowUpperBound="50" highLowerBound="90"/>
		</report>
	</coverage>
	<logging>
    	<testdoxHtml outputFile="coverage-report/testdox.html"/>
	</logging>
</phpunit>

This Is my test class:

/**
 * Part of Omega CMS -  Environment Test Package
 *
 * @link       https://omegacms.github.io
 * @author     Adriano Giovannini <omegacms@outlook.com>
 * @copyright  Copyright (c) 2024 Adriano Giovannini. (https://omegacms.github.io)
 * @license    https://www.gnu.org/licenses/gpl-3.0-standalone.html     GPL V3.0+
 */

/**
 * @declare
 */
declare( strict_types = 1 );

/**
 * @namespace
 */
namespace Omega\Environment\Tests;

/**
 * @use
 */
use Omega\Environment\Dotenv;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\Attributes\TestDox;
use Omega\Testing\TestCase;

/**
 * Dotenv test class.
 *
 * The `DotenvTest` class extends the `Omega\Testing\TestCase` class and tests
 * functionalities of the `Omega\Environment\Dotenv` class. It likely uses a `.env.test`
 * file located in the fixtures directory for testing purposes.
 *
 * @category    Omega
 * @package     Omega\Environment
 * @subpackage  Omega\Environment\Tests
 * @link        https://omegacms.github.io
 * @author      Adriano Giovannini <omegacms@outlook.com>
 * @copyright   Copyright (c) 2024 Adriano Giovannini. (https://omegacms.github.io)
 * @license     https://www.gnu.org/licenses/gpl-3.0-standalone.html     GPL V3.0+
 * @version     1.0.0
 */
class DotenvTest extends TestCase
{
    /**
     * Tear down.
     *
     * This method is executed after each test case. It clears any loaded environment
     * variables using `Dotenv::flush()` and resets required environment variables to
     * an empty array using `Dotenv::setRequired( [] )`.
     *
     * @return void
     */
    public function tearDown() : void
    {
        Dotenv::flush();

        Dotenv::setRequired([]);
    }

    /**
     * Test it can load env file and give access to var using all.
     *
     * This test simulates loading the .env.test file and asserts that the loaded
     * variables can be accessed using the `all()` method. It also verifies that the
     * loaded variables match the expected values.
     *
     * @return void
     */
     #[Test]
     #[TestDox('Test it can load .env file and gives access to var using all.

    This test simulates loading the .env.test file and asserts that the loaded
    variables can be accessed using the all() method. It also verifies that the
    loaded variables match the expected values.
    ')]
    public function itCanLoadEnvFileAndGivesAccessToVarsUsingAll() : void
    {
        Dotenv::flush();

        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        $expected = [
            'DB_USER'         => 'root',
            'DB_PASSWORD'     => 'secret',
            'DB_NAME'         => 'test',
            'TEST_USER'       => 'root',
            'TEST_SOME_ARRAY' => 'FOO'
        ];

        $this->assertSame( $expected, Dotenv::all() );
    }

    /**
     * Test it can load array.
     *
     * Similar to the previous test, this test loads the `.env.test` file and asserts that
     * the loaded variables accessible through `all()` match the expected values.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Test it can load array.

    Similar to the previous test, this test loads the .env.test file and asserts that
    the loaded variables accessible through all() match the expected values.
    ')]
    public function itCanLoadArray() : void
    {
    	Dotenv::flush();

        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        $loadedVariables = Dotenv::all();

        $expected = [
            'DB_USER'         => 'root',
            'DB_PASSWORD'     => 'secret',
            'DB_NAME'         => 'test',
            'TEST_USER'       => 'root',
            'TEST_SOME_ARRAY' => 'FOO',
        ];

        $this->assertSame( $expected, $loadedVariables );
    }

    /**
     * Flush method.
     *
     * This test loads the `.env.test` file and then uses the `flush()` method to clear
     * the loaded variables. Finally, it asserts that `all()` returns an empty array
     * after flushing.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Flush method.

    This test loads the .env.test file and then uses the `flush()` method to clear
    the loaded variables. Finally, it asserts that all() returns an empty array
    after flushing.
    ')]
    public function flushMethod() : void
    {
        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        Dotenv::flush();

        $this->assertSame( [], Dotenv::all() );
    }

    /**
     * Get method.
     *
     * This test loads the .env.test file and tests the behavior of the get() method in various scenarios:
     *
     * * Retrieving an existing variable (`DB_USER`).
     * * Retrieving an existing variable with a default value (`DB_USER`, `foo`).
     * * Retrieving a non-existent variable (`DB_PASSWORD`).
     * * Retrieving a non-existent variable with a default value (`DB_PASSWORD`, `foo`).
     *
     * @return void
     */
    #[Test]
    #[TestDox('Get method.

    This test loads the .env.test file and tests the behavior of the get() method in various scenarios:
     * Retrieving an existing variable (`DB_USER`).
     * Retrieving an existing variable with a default value (`DB_USER`, `foo`).
     * Retrieving a non-existent variable (`DB_PASSWORD`).
     * Retrieving a non-existent variable with a default value (`DB_PASSWORD`, `foo`).
    ')]
    public function getMethod() : void
    {
        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        Dotenv::set( [
            'DB_PASSWORD' => '',
        ] );

        $this->assertSame( 'root', Dotenv::get( 'DB_USER'            ) );
        $this->assertSame( 'root', Dotenv::get( 'DB_USER',     'foo' ) );
        $this->assertSame(   null, Dotenv::get( 'DB_PASSWORD'        ) );
        $this->assertSame(  'foo', Dotenv::get( 'DB_PASSWORD', 'foo' ) );
    }

    /**
     * Test set method with two array.
     *
     * This test loads the `.env.test` file and then uses the `set()` method with two
     * arguments to update the value of a specific variable (`DB_PASSWORD`). It then
     * asserts that the updated value is accessible through `get()`.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Test set method with two array.

    This test loads the `.env.test` file and then uses the `set()` method with two
    arguments to update the value of a specific variable (`DB_PASSWORD`). It then
    asserts that the updated value is accessible through `get()`.
    ')]
    public function setMethodWithTwoArgs() : void
    {
        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        Dotenv::set( 'DB_PASSWORD', 'secret' );

        $this->assertSame( 'root',   Dotenv::get( 'DB_USER'     ) );
        $this->assertSame( 'secret', Dotenv::get( 'DB_PASSWORD' ) );
    }

    /**
     * Test set method with array.
     *
     * This test loads the .env.test file and then uses the `set()` method with
     * an array to update the values of multiple variables. It asserts that the
     * updated values are accessible through `get()`.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Test set method with array.

    This test loads .env.test file and then uses the set()( method with
    an array to update the values of multiple variables. It assert that
    the updated values are accessible through get().
    ')]
    public function setMethodWithArray() : void
    {
        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        Dotenv::set( [
            'DB_PASSWORD' => 'secret',
            'DB_NAME'     => 'test',
        ] );

        $this->assertSame(   'root', Dotenv::get( 'DB_USER'     ) );
        $this->assertSame( 'secret', Dotenv::get( 'DB_PASSWORD' ) );
        $this->assertSame(   'test', Dotenv::get( 'DB_NAME'     ) );
    }

    /**
     * Test it throws missing var exception.
     *
     * This test tests the behavior when required environment variables are not defined in
     * the loaded `.env.test` file. It sets required variables (`DB_HOST`, `DB_TYPE`) and
     * expects a `MissingVariableException` to be thrown during loading.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Test it throws missing var exception.

    This test tests the behavior when required environment variables are not defined in
    the loaded `.env.test` file. It sets required variables (`DB_HOST`, `DB_TYPE`) and
    expects a `MissingVariableException` to be thrown during loading.
    ')]
    public function itThrowsMissingVarException() : void
    {
        // Imposta le variabili richieste
        Dotenv::setRequired([
            'DB_HOST',
            'DB_TYPE'
        ]);

        $this->expectException(\Omega\Environment\Exception\MissingVariableException::class);

        Dotenv::load(__DIR__ . '/fixtures', '.env.test');
    }

    /**
     * Test it throws is missing var exception even after load.
     *
     * Similar to the previous test, this test loads the `.env.test` file and then sets required
     * variables (`DB_HOST`, `DB_TYPE`). It expects a `MissingVariableException` to be thrown
     * regardless of the prior loading.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Test it throws is missing var exception even after load.

    Similar to the previous test, this test loads the `.env.test` file and then sets required
    variables (`DB_HOST`, `DB_TYPE`). It expects a `MissingVariableException` to be thrown
    regardless of the prior loading.
    ')]
    public function itThrowIsMissingVarExceptionEvenAfterLoad() : void
    {
        $this->expectException( \Omega\Environment\Exception\MissingVariableException::class );

        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        Dotenv::setRequired( [
            'DB_HOST',
            'DB_TYPE'
        ] );
    }

    /**
     * Test it does not throw missing var exception if all required vars are set.
     *
     * This test sets required variables (`DB_USER`, `DB_PASSWORD`) and then loads the `.env.test` file.
     * It verifies that the loading is successful and the required variables are accessible through `all()`.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Test it does not throw missing var exception if all required vars are set.

    This test sets required variables (`DB_USER`, `DB_PASSWORD`) and then loads the `.env.test` file.
    It verifies that the loading is successful and the required variables are accessible through `all()`.
    ')]
    public function itDoesNotThrowMissingVarExceptionIfAllRequiredVarsAreSet() : void
    {
        Dotenv::setRequired([
            'DB_USER',
            'DB_PASSWORD'
        ]);

        Dotenv::load(__DIR__ . '/fixtures', '.env.test');

        $this->assertArrayHasKey('DB_USER', Dotenv::all());
        $this->assertArrayHasKey('DB_PASSWORD', Dotenv::all());
    }

    /**
     * Test it can copy vars to putenv.
     *
     * This test loads the `.env.test` file and then uses `copyVarsToPutenv()` to
     * copy the loaded variables to the putenv function. It asserts that the copied
     * variables are accessible through the `getenv()` function.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Test it can copy vars to putenv.

    This test loads the `.env.test` file and then uses `copyVarsToPutenv()` to
    copy the loaded variables to the putenv function. It asserts that the copied
    variables are accessible through the `getenv()` function.
    ')]
    public function itCanCopyVarsToPutenv() : void
    {
        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        Dotenv::copyVarsToPutenv();

        $this->assertSame( 'root', getenv( 'PHP_TEST_USER'       ) );
        $this->assertSame(  'FOO', getenv( 'PHP_TEST_SOME_ARRAY' ) );
    }

        /**
     * Test it can copy vars to server.
     *
     * This test loads the `.env.test` file and then uses `copyVarsToServer()` to copy the
     * loaded variables to the `$_SERVER` superglobal. It asserts that the copied variables
     * are accessible through `$_SERVER`.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Test it can copy vars to server.

    This test loads the `.env.test` file and then uses `copyVarsToServer()` to copy the
    loaded variables to the `$_SERVER` superglobal. It asserts that the copied variables
    are accessible through `$_SERVER`.
    ')]
    public function itCanCopyVarsToServer() : void
    {
        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        Dotenv::copyVarsToServer();

        $this->assertSame( 'root', $_SERVER[ 'TEST_USER'       ] );
        $this->assertSame(  'FOO', $_SERVER[ 'TEST_SOME_ARRAY' ] );

        unset( $_SERVER[ 'TEST_USER' ], $_SERVER ['TEST_SOME_ARRAY' ] );
    }

    /**
     * Test it can copy vars to env.
     *
     * This test loads the `.env.test` file and then uses `copyVarsToEnv()` to copy
     * the loaded variables to the `$_ENV` superglobal. It asserts that the copied
     * variables are accessible through `$_ENV`.
     *
     * @return void
     */
    #[Test]
    #[TestDox('Test it can copy vars to env.

    This test loads the `.env.test` file and then uses `copyVarsToEnv()` to copy
    the loaded variables to the `$_ENV` superglobal. It asserts that the copied
    variables are accessible through `$_ENV`.
    ')]
    public function itCanCopyVarsToEnv() : void
    {
        Dotenv::load( __DIR__ . '/fixtures', '.env.test' );

        Dotenv::copyVarsToEnv();

        $this->assertSame( 'root', $_ENV[ 'TEST_USER'       ] );
        $this->assertSame(  'FOO', $_ENV[ 'TEST_SOME_ARRAY' ] );

        unset( $_ENV[ 'TEST_USER' ], $_ENV[ 'TEST_SOME_ARRAY' ] );
    }
}

This Is the output.

Dotenv (Omega\Environment\Tests\Dotenv)
 ✔ Test it can load .env file and gives access to var using all.
     
    This test simulates loading the .env.test file and asserts that the loaded
    variables can be accessed using the all() method. It also verifies that the
    loaded variables match the expected values.
    
 ✔ Test it can load array.

    Similar to the previous test, this test loads the .env.test file and asserts that 
    the loaded variables accessible through all() match the expected values.
    
 ✔ Flush method.
    
    This test loads the .env.test file and then uses the `flush()` method to clear 
    the loaded variables. Finally, it asserts that all() returns an empty array 
    after flushing.
    
 ✔ Get method.
    
    This test loads the .env.test file and tests the behavior of the get() method in various scenarios:
     * Retrieving an existing variable (`DB_USER`).
     * Retrieving an existing variable with a default value (`DB_USER`, `foo`).
     * Retrieving a non-existent variable (`DB_PASSWORD`).
     * Retrieving a non-existent variable with a default value (`DB_PASSWORD`, `foo`).
    
 ✔ Test set method with two array.
 
    This test loads the `.env.test` file and then uses the `set()` method with two 
    arguments to update the value of a specific variable (`DB_PASSWORD`). It then 
    asserts that the updated value is accessible through `get()`.
    
 ✔ Test set method with array.

    This test loads .env.test file and then uses the set()( method with
    an array to update the values of multiple variables. It assert that 
    the updated values are accessible through get().
    
 ✔ Test it throws missing var exception.
     
    This test tests the behavior when required environment variables are not defined in 
    the loaded `.env.test` file. It sets required variables (`DB_HOST`, `DB_TYPE`) and 
    expects a `MissingVariableException` to be thrown during loading.
    
 ✔ Test it throws is missing var exception even after load.
    
    Similar to the previous test, this test loads the `.env.test` file and then sets required
    variables (`DB_HOST`, `DB_TYPE`). It expects a `MissingVariableException` to be thrown
    regardless of the prior loading.
    
 ✔ Test it does not throw missing var exception if all required vars are set.
    
    This test sets required variables (`DB_USER`, `DB_PASSWORD`) and then loads the `.env.test` file.
    It verifies that the loading is successful and the required variables are accessible through `all()`.
    
 ✔ Test it can copy vars to putenv.
    
    This test loads the `.env.test` file and then uses `copyVarsToPutenv()` to
    copy the loaded variables to the putenv function. It asserts that the copied
    variables are accessible through the `getenv()` function.
    
 ✔ Test it can copy vars to server.
    
    This test loads the `.env.test` file and then uses `copyVarsToServer()` to copy the
    loaded variables to the `$_SERVER` superglobal. It asserts that the copied variables
    are accessible through `$_SERVER`.
 ✔ Test it can copy vars to env.
    
    This test loads the `.env.test` file and then uses `copyVarsToEnv()` to copy
    the loaded variables to the `$_ENV` superglobal. It asserts that the copied
    variables are accessible through `$_ENV`.

It can be observed that there is no spacing between the title of the final method in the class and the descriptive text of the preceding method.

Thanks in advanced.
Adriano

The text was updated successfully, but these errors were encountered:

sebastianbergmann · 2024-09-12T12:13:52Z

Thank you for your report.

Please provide a minimal, self-contained, reproducing test case that shows the problem you are reporting.

Without such a minimal, self-contained, reproducing test case I will not be able to investigate this issue.

omegacms · 2024-09-12T12:39:07Z

Hallo Sebastian and thanks for response.

Due to the complexity of the framework I'm developing, isolating the issue into a minimal reproducible example is not straightforward. The problem is uniquely confined to the framework's test suite.

I've investigated the problem and from the testdox.html file I've noticed that the </li> tags related to the last two test are not closed as the others.

This is the code of the testdox.html file related to the tests of that class.

       <h2>Dotenv (Omega\Environment\Tests\Dotenv)</h2>
        <ul>
            <li class="success">Test it can load .env file and gives access to var using all.

    This test simulates loading the .env.test file and asserts that the loaded
    variables can be accessed using the all() method. It also verifies that the
    loaded variables match the expected values.
    </li>
            <li class="success">Test it can load array.

    Similar to the previous test, this test loads the .env.test file and asserts that
    the loaded variables accessible through all() match the expected values.
    </li>
            <li class="success">Flush method.

    This test loads the .env.test file and then uses the `flush()` method to clear
    the loaded variables. Finally, it asserts that all() returns an empty array
    after flushing.
    </li>
            <li class="success">Get method.

    This test loads the .env.test file and tests the behavior of the get() method in various scenarios:
     * Retrieving an existing variable (`DB_USER`).
     * Retrieving an existing variable with a default value (`DB_USER`, `foo`).
     * Retrieving a non-existent variable (`DB_PASSWORD`).
     * Retrieving a non-existent variable with a default value (`DB_PASSWORD`, `foo`).
    </li>
            <li class="success">Test set method with two array.

    This test loads the `.env.test` file and then uses the `set()` method with two
    arguments to update the value of a specific variable (`DB_PASSWORD`). It then
    asserts that the updated value is accessible through `get()`.
    </li>
            <li class="success">Test set method with array.

    This test loads .env.test file and then uses the set()( method with
    an array to update the values of multiple variables. It assert that
    the updated values are accessible through get().
    </li>
            <li class="success">Test it throws missing var exception.

    This test tests the behavior when required environment variables are not defined in
    the loaded `.env.test` file. It sets required variables (`DB_HOST`, `DB_TYPE`) and
    expects a `MissingVariableException` to be thrown during loading.
    </li>
            <li class="success">Test it throws is missing var exception even after load.

    Similar to the previous test, this test loads the `.env.test` file and then sets required
    variables (`DB_HOST`, `DB_TYPE`). It expects a `MissingVariableException` to be thrown
    regardless of the prior loading.
    </li>
            <li class="success">Test it does not throw missing var exception if all required vars are set.

    This test sets required variables (`DB_USER`, `DB_PASSWORD`) and then loads the `.env.test` file.
    It verifies that the loading is successful and the required variables are accessible through `all()`.
    </li>
            <li class="success">Test it can copy vars to putenv.

    This test loads the `.env.test` file and then uses `copyVarsToPutenv()` to
    copy the loaded variables to the putenv function. It asserts that the copied
    variables are accessible through the `getenv()` function.
    </li>
            <li class="success">Test it can copy vars to server.

    This test loads the `.env.test` file and then uses `copyVarsToServer()` to copy the
    loaded variables to the `$_SERVER` superglobal. It asserts that the copied variables
    are accessible through `$_SERVER`.</li>
            <li class="success">Test it can copy vars to env.

    This test loads the `.env.test` file and then uses `copyVarsToEnv()` to copy
    the loaded variables to the `$_ENV` superglobal. It asserts that the copied
    variables are accessible through `$_ENV`.</li>
        </ul>

As you can see, there is no line break and the tag, unlike what happens with the other methods, is closed immediately after the text. I can't tell you why this is happening.

Thanks and Sorry.

omegacms · 2024-09-12T13:12:04Z

I investigate into the phpunit source code and found two possible issue in HtmlRender class.

Issue 1: Extraneous Comma After $prettifiedClassName

In the render method of the HtmlRenderer class, there is an unnecessary comma after the $prettifiedClassName variable in the sprintf function call:

While this extra comma does not produce a syntax error, it may introduce unintended behavior in some contexts, especially depending on the PHP version in use. It is a minor formatting issue but should be removed for better code clarity and to avoid any potential parsing confusion.

Issue 2: Missing Newline After </li> Tags

In the generated HTML output, there is a missing newline character (\n) after the closing tag for the last two list items. This inconsistency in formatting can be seen in the HTML output provided, where some tags are followed by a newline, but others are not.

This can be fixed by adding an additional \n after each to ensure that the line breaks are consistent throughout the output. The updated code would look like this:

$buffer .= sprintf(
    "            <li class=\"%s\">%s</li>\n\n", // <-- added second newline
    $outcome,
    $prettifiedMethodName
);

The second newline guarantees that even the final list items have a consistent format and include proper line breaks in the HTML structure. This makes the output easier to read and avoids any issues with missing line breaks in specific cases.

I hope I have been helpful

sebastianbergmann · 2024-09-12T13:15:06Z

PHPUnit 11 is not supported on versions of PHP that do not support "extraneous" commas. Why would a missing newline after an </li> matter?

omegacms · 2024-09-12T16:07:32Z

To tell the truth, the idea came from the fact that I have already had similar experiences and in the end the problems were always of this type.

sebastianbergmann · 2024-09-12T17:28:27Z

I do not understand what you are trying to report as in #5949 (comment) you are showing TestDox text output and in #5949 (comment) you talk about TestDox HTML output.

Please provide a minimal, self-contained, reproducing test case that shows the problem you are reporting.

omegacms added the type/bug Something is broken label Sep 12, 2024

sebastianbergmann added status/waiting-for-feedback Waiting for feedback from original reporter feature/testdox The TextDox printer/formatter labels Sep 12, 2024

kubawerlos mentioned this issue Sep 13, 2024

Do not trim testdox text when it contains $ character #5950

Merged

sebastianbergmann closed this as completed Sep 14, 2024

sebastianbergmann removed the status/waiting-for-feedback Waiting for feedback from original reporter label Sep 14, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Output formatting issue in PHPUnit with TestDox #5949

Output formatting issue in PHPUnit with TestDox #5949

omegacms commented Sep 12, 2024 •

edited

Loading

sebastianbergmann commented Sep 12, 2024

omegacms commented Sep 12, 2024 •

edited

Loading

omegacms commented Sep 12, 2024

sebastianbergmann commented Sep 12, 2024

omegacms commented Sep 12, 2024

sebastianbergmann commented Sep 12, 2024

Output formatting issue in PHPUnit with TestDox #5949

Output formatting issue in PHPUnit with TestDox #5949

Comments

omegacms commented Sep 12, 2024 • edited Loading

sebastianbergmann commented Sep 12, 2024

omegacms commented Sep 12, 2024 • edited Loading

omegacms commented Sep 12, 2024

sebastianbergmann commented Sep 12, 2024

omegacms commented Sep 12, 2024

sebastianbergmann commented Sep 12, 2024

omegacms commented Sep 12, 2024 •

edited

Loading

omegacms commented Sep 12, 2024 •

edited

Loading