<form method="POST">
    <h3>Editing: XmlResultPrinter.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Util\TestDox;

use function array_filter;
use function get_class;
use function implode;
use function strpos;
use DOMDocument;
use DOMElement;
use PHPUnit\Framework\AssertionFailedError;
use PHPUnit\Framework\Exception;
use PHPUnit\Framework\Test;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestListener;
use PHPUnit\Framework\TestSuite;
use PHPUnit\Framework\Warning;
use PHPUnit\Framework\WarningTestCase;
use PHPUnit\Util\Printer;
use PHPUnit\Util\Test as TestUtil;
use ReflectionClass;
use ReflectionException;
use SebastianBergmann\RecursionContext\InvalidArgumentException;
use Throwable;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
final class XmlResultPrinter extends Printer implements TestListener
{
    /**
     * @var DOMDocument
     */
    private $document;

    /**
     * @var DOMElement
     */
    private $root;

    /**
     * @var NamePrettifier
     */
    private $prettifier;

    /**
     * @var null|Throwable
     */
    private $exception;

    /**
     * @param resource|string $out
     *
     * @throws Exception
     */
    public function __construct($out = null)
    {
        $this-&gt;document               = new DOMDocument('1.0', 'UTF-8');
        $this-&gt;document-&gt;formatOutput = true;

        $this-&gt;root = $this-&gt;document-&gt;createElement('tests');
        $this-&gt;document-&gt;appendChild($this-&gt;root);

        $this-&gt;prettifier = new NamePrettifier;

        parent::__construct($out);
    }

    /**
     * Flush buffer and close output.
     */
    public function flush(): void
    {
        $this-&gt;write($this-&gt;document-&gt;saveXML());

        parent::flush();
    }

    /**
     * An error occurred.
     */
    public function addError(Test $test, Throwable $t, float $time): void
    {
        $this-&gt;exception = $t;
    }

    /**
     * A warning occurred.
     */
    public function addWarning(Test $test, Warning $e, float $time): void
    {
    }

    /**
     * A failure occurred.
     */
    public function addFailure(Test $test, AssertionFailedError $e, float $time): void
    {
        $this-&gt;exception = $e;
    }

    /**
     * Incomplete test.
     */
    public function addIncompleteTest(Test $test, Throwable $t, float $time): void
    {
    }

    /**
     * Risky test.
     */
    public function addRiskyTest(Test $test, Throwable $t, float $time): void
    {
    }

    /**
     * Skipped test.
     */
    public function addSkippedTest(Test $test, Throwable $t, float $time): void
    {
    }

    /**
     * A test suite started.
     */
    public function startTestSuite(TestSuite $suite): void
    {
    }

    /**
     * A test suite ended.
     */
    public function endTestSuite(TestSuite $suite): void
    {
    }

    /**
     * A test started.
     */
    public function startTest(Test $test): void
    {
        $this-&gt;exception = null;
    }

    /**
     * A test ended.
     *
     * @throws InvalidArgumentException
     */
    public function endTest(Test $test, float $time): void
    {
        if (!$test instanceof TestCase || $test instanceof WarningTestCase) {
            return;
        }

        $groups = array_filter(
            $test-&gt;getGroups(),
            static function ($group)
            {
                return !($group === 'small' || $group === 'medium' || $group === 'large' || strpos($group, '__phpunit_') === 0);
            },
        );

        $testNode = $this-&gt;document-&gt;createElement('test');

        $testNode-&gt;setAttribute('className', get_class($test));
        $testNode-&gt;setAttribute('methodName', $test-&gt;getName());
        $testNode-&gt;setAttribute('prettifiedClassName', $this-&gt;prettifier-&gt;prettifyTestClass(get_class($test)));
        $testNode-&gt;setAttribute('prettifiedMethodName', $this-&gt;prettifier-&gt;prettifyTestCase($test));
        $testNode-&gt;setAttribute('status', (string) $test-&gt;getStatus());
        $testNode-&gt;setAttribute('time', (string) $time);
        $testNode-&gt;setAttribute('size', (string) $test-&gt;getSize());
        $testNode-&gt;setAttribute('groups', implode(',', $groups));

        foreach ($groups as $group) {
            $groupNode = $this-&gt;document-&gt;createElement('group');

            $groupNode-&gt;setAttribute('name', $group);

            $testNode-&gt;appendChild($groupNode);
        }

        $annotations = TestUtil::parseTestMethodAnnotations(
            get_class($test),
            $test-&gt;getName(false),
        );

        foreach (['class', 'method'] as $type) {
            foreach ($annotations[$type] as $annotation =&gt; $values) {
                if ($annotation !== 'covers' &amp;&amp; $annotation !== 'uses') {
                    continue;
                }

                foreach ($values as $value) {
                    $coversNode = $this-&gt;document-&gt;createElement($annotation);

                    $coversNode-&gt;setAttribute('target', $value);

                    $testNode-&gt;appendChild($coversNode);
                }
            }
        }

        foreach ($test-&gt;doubledTypes() as $doubledType) {
            $testDoubleNode = $this-&gt;document-&gt;createElement('testDouble');

            $testDoubleNode-&gt;setAttribute('type', $doubledType);

            $testNode-&gt;appendChild($testDoubleNode);
        }

        $inlineAnnotations = TestUtil::getInlineAnnotations(get_class($test), $test-&gt;getName(false));

        if (isset($inlineAnnotations['given'], $inlineAnnotations['when'], $inlineAnnotations['then'])) {
            $testNode-&gt;setAttribute('given', $inlineAnnotations['given']['value']);
            $testNode-&gt;setAttribute('givenStartLine', (string) $inlineAnnotations['given']['line']);
            $testNode-&gt;setAttribute('when', $inlineAnnotations['when']['value']);
            $testNode-&gt;setAttribute('whenStartLine', (string) $inlineAnnotations['when']['line']);
            $testNode-&gt;setAttribute('then', $inlineAnnotations['then']['value']);
            $testNode-&gt;setAttribute('thenStartLine', (string) $inlineAnnotations['then']['line']);
        }

        if ($this-&gt;exception !== null) {
            if ($this-&gt;exception instanceof Exception) {
                $steps = $this-&gt;exception-&gt;getSerializableTrace();
            } else {
                $steps = $this-&gt;exception-&gt;getTrace();
            }

            try {
                $file = (new ReflectionClass($test))-&gt;getFileName();
                // @codeCoverageIgnoreStart
            } catch (ReflectionException $e) {
                throw new Exception(
                    $e-&gt;getMessage(),
                    $e-&gt;getCode(),
                    $e,
                );
            }
            // @codeCoverageIgnoreEnd

            foreach ($steps as $step) {
                if (isset($step['file']) &amp;&amp; $step['file'] === $file) {
                    $testNode-&gt;setAttribute('exceptionLine', (string) $step['line']);

                    break;
                }
            }

            $testNode-&gt;setAttribute('exceptionMessage', $this-&gt;exception-&gt;getMessage());
        }

        $this-&gt;root-&gt;appendChild($testNode);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>