Your IP : 216.73.216.79
<?php declare(strict_types=1);
/*
* This file is part of PHPUnit.
*
* (c) Sebastian Bergmann <sebastian@phpunit.de>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Event;
use function assert;
use function memory_reset_peak_usage;
use function preg_match;
use PHPUnit\Event\Code\ClassMethod;
use PHPUnit\Event\Code\ComparisonFailure;
use PHPUnit\Event\Code\IssueTrigger\IssueTrigger;
use PHPUnit\Event\Code\NoTestCaseObjectOnCallStackException;
use PHPUnit\Event\Code\TestMethod;
use PHPUnit\Event\Code\TestMethodBuilder;
use PHPUnit\Event\Code\Throwable;
use PHPUnit\Event\Test\DataProviderMethodCalled;
use PHPUnit\Event\Test\DataProviderMethodFinished;
use PHPUnit\Event\TestSuite\Filtered as TestSuiteFiltered;
use PHPUnit\Event\TestSuite\Finished as TestSuiteFinished;
use PHPUnit\Event\TestSuite\Loaded as TestSuiteLoaded;
use PHPUnit\Event\TestSuite\Skipped as TestSuiteSkipped;
use PHPUnit\Event\TestSuite\Sorted as TestSuiteSorted;
use PHPUnit\Event\TestSuite\Started as TestSuiteStarted;
use PHPUnit\Event\TestSuite\TestSuite;
use PHPUnit\Framework\TestCase;
use PHPUnit\Metadata\IgnorePhpunitWarnings;
use PHPUnit\Metadata\Parser\Registry;
use PHPUnit\TextUI\Configuration\Configuration;
use SebastianBergmann\Comparator\Comparator;
/**
* @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
*
* @internal This class is not covered by the backward compatibility promise for PHPUnit
*/
final class DispatchingEmitter implements Emitter
{
private readonly Dispatcher $dispatcher;
private readonly Telemetry\System $system;
private readonly Telemetry\Snapshot $startSnapshot;
private Telemetry\Snapshot $previousSnapshot;
public function __construct(Dispatcher $dispatcher, Telemetry\System $system)
{
$this->dispatcher = $dispatcher;
$this->system = $system;
$this->startSnapshot = $system->snapshot();
$this->previousSnapshot = $this->startSnapshot;
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function applicationStarted(): void
{
$this->dispatcher->dispatch(
new Application\Started(
$this->telemetryInfo(),
new Runtime\Runtime,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerStarted(): void
{
$this->dispatcher->dispatch(
new TestRunner\Started(
$this->telemetryInfo(),
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerConfigured(Configuration $configuration): void
{
$this->dispatcher->dispatch(
new TestRunner\Configured(
$this->telemetryInfo(),
$configuration,
),
);
}
/**
* @param non-empty-string $filename
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerBootstrapFinished(string $filename): void
{
$this->dispatcher->dispatch(
new TestRunner\BootstrapFinished(
$this->telemetryInfo(),
$filename,
),
);
}
/**
* @param non-empty-string $filename
* @param non-empty-string $name
* @param non-empty-string $version
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerLoadedExtensionFromPhar(string $filename, string $name, string $version): void
{
$this->dispatcher->dispatch(
new TestRunner\ExtensionLoadedFromPhar(
$this->telemetryInfo(),
$filename,
$name,
$version,
),
);
}
/**
* @param class-string $className
* @param array<string, string> $parameters
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerBootstrappedExtension(string $className, array $parameters): void
{
$this->dispatcher->dispatch(
new TestRunner\ExtensionBootstrapped(
$this->telemetryInfo(),
$className,
$parameters,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function dataProviderMethodCalled(ClassMethod $testMethod, ClassMethod $dataProviderMethod): void
{
$this->dispatcher->dispatch(
new DataProviderMethodCalled(
$this->telemetryInfo(),
$testMethod,
$dataProviderMethod,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function dataProviderMethodFinished(ClassMethod $testMethod, ClassMethod ...$calledMethods): void
{
$this->dispatcher->dispatch(
new DataProviderMethodFinished(
$this->telemetryInfo(),
$testMethod,
...$calledMethods,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testSuiteLoaded(TestSuite $testSuite): void
{
$this->dispatcher->dispatch(
new TestSuiteLoaded(
$this->telemetryInfo(),
$testSuite,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testSuiteFiltered(TestSuite $testSuite): void
{
$this->dispatcher->dispatch(
new TestSuiteFiltered(
$this->telemetryInfo(),
$testSuite,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testSuiteSorted(int $executionOrder, int $executionOrderDefects, bool $resolveDependencies): void
{
$this->dispatcher->dispatch(
new TestSuiteSorted(
$this->telemetryInfo(),
$executionOrder,
$executionOrderDefects,
$resolveDependencies,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerEventFacadeSealed(): void
{
$this->dispatcher->dispatch(
new TestRunner\EventFacadeSealed(
$this->telemetryInfo(),
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerExecutionStarted(TestSuite $testSuite): void
{
$this->dispatcher->dispatch(
new TestRunner\ExecutionStarted(
$this->telemetryInfo(),
$testSuite,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerDisabledGarbageCollection(): void
{
$this->dispatcher->dispatch(
new TestRunner\GarbageCollectionDisabled($this->telemetryInfo()),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerTriggeredGarbageCollection(): void
{
$this->dispatcher->dispatch(
new TestRunner\GarbageCollectionTriggered($this->telemetryInfo()),
);
}
public function childProcessStarted(): void
{
$this->dispatcher->dispatch(
new TestRunner\ChildProcessStarted($this->telemetryInfo()),
);
}
public function childProcessErrored(): void
{
$this->dispatcher->dispatch(
new TestRunner\ChildProcessErrored($this->telemetryInfo()),
);
}
public function childProcessFinished(string $stdout, string $stderr): void
{
$this->dispatcher->dispatch(
new TestRunner\ChildProcessFinished(
$this->telemetryInfo(),
$stdout,
$stderr,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testSuiteSkipped(TestSuite $testSuite, string $message): void
{
$this->dispatcher->dispatch(
new TestSuiteSkipped(
$this->telemetryInfo(),
$testSuite,
$message,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testSuiteStarted(TestSuite $testSuite): void
{
$this->dispatcher->dispatch(
new TestSuiteStarted(
$this->telemetryInfo(),
$testSuite,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testPreparationStarted(Code\Test $test): void
{
$this->dispatcher->dispatch(
new Test\PreparationStarted(
$this->telemetryInfo(),
$test,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testPreparationErrored(Code\Test $test, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\PreparationErrored(
$this->telemetryInfo(),
$test,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testPreparationFailed(Code\Test $test, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\PreparationFailed(
$this->telemetryInfo(),
$test,
$throwable,
),
);
}
/**
* @param class-string<TestCase> $testClassName
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function beforeFirstTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void
{
$this->dispatcher->dispatch(
new Test\BeforeFirstTestMethodCalled(
$this->telemetryInfo(),
$testClassName,
$calledMethod,
),
);
}
/**
* @param class-string<TestCase> $testClassName
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function beforeFirstTestMethodErrored(string $testClassName, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\BeforeFirstTestMethodErrored(
$this->telemetryInfo(),
$testClassName,
$calledMethod,
$throwable,
),
);
}
/**
* @param class-string<TestCase> $testClassName
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function beforeFirstTestMethodFailed(string $testClassName, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\BeforeFirstTestMethodFailed(
$this->telemetryInfo(),
$testClassName,
$calledMethod,
$throwable,
),
);
}
/**
* @param class-string<TestCase> $testClassName
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function beforeFirstTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void
{
$this->dispatcher->dispatch(
new Test\BeforeFirstTestMethodFinished(
$this->telemetryInfo(),
$testClassName,
...$calledMethods,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function beforeTestMethodCalled(TestMethod $test, ClassMethod $calledMethod): void
{
$this->dispatcher->dispatch(
new Test\BeforeTestMethodCalled(
$this->telemetryInfo(),
$test,
$calledMethod,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function beforeTestMethodErrored(TestMethod $test, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\BeforeTestMethodErrored(
$this->telemetryInfo(),
$test,
$calledMethod,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function beforeTestMethodFailed(TestMethod $test, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\BeforeTestMethodFailed(
$this->telemetryInfo(),
$test,
$calledMethod,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function beforeTestMethodFinished(TestMethod $test, ClassMethod ...$calledMethods): void
{
$this->dispatcher->dispatch(
new Test\BeforeTestMethodFinished(
$this->telemetryInfo(),
$test,
...$calledMethods,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function preConditionCalled(TestMethod $test, ClassMethod $calledMethod): void
{
$this->dispatcher->dispatch(
new Test\PreConditionCalled(
$this->telemetryInfo(),
$test,
$calledMethod,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function preConditionErrored(TestMethod $test, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\PreConditionErrored(
$this->telemetryInfo(),
$test,
$calledMethod,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function preConditionFailed(TestMethod $test, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\PreConditionFailed(
$this->telemetryInfo(),
$test,
$calledMethod,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function preConditionFinished(TestMethod $test, ClassMethod ...$calledMethods): void
{
$this->dispatcher->dispatch(
new Test\PreConditionFinished(
$this->telemetryInfo(),
$test,
...$calledMethods,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testPrepared(Code\Test $test): void
{
memory_reset_peak_usage();
$this->dispatcher->dispatch(
new Test\Prepared(
$this->telemetryInfo(),
$test,
),
);
}
/**
* @param class-string<Comparator> $className
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRegisteredComparator(string $className): void
{
$this->dispatcher->dispatch(
new Test\ComparatorRegistered(
$this->telemetryInfo(),
$className,
),
);
}
public function testUsedCustomMethodInvocation(TestMethod $test, ClassMethod $customTestMethodInvocation): void
{
$this->dispatcher->dispatch(
new Test\CustomTestMethodInvocationUsed(
$this->telemetryInfo(),
$test,
$customTestMethodInvocation,
),
);
}
/**
* @param class-string $className
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testCreatedMockObject(string $className): void
{
$this->dispatcher->dispatch(
new Test\MockObjectCreated(
$this->telemetryInfo(),
$className,
),
);
}
/**
* @param list<class-string> $interfaces
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testCreatedMockObjectForIntersectionOfInterfaces(array $interfaces): void
{
$this->dispatcher->dispatch(
new Test\MockObjectForIntersectionOfInterfacesCreated(
$this->telemetryInfo(),
$interfaces,
),
);
}
/**
* @param class-string $className
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testCreatedPartialMockObject(string $className, string ...$methodNames): void
{
$this->dispatcher->dispatch(
new Test\PartialMockObjectCreated(
$this->telemetryInfo(),
$className,
...$methodNames,
),
);
}
/**
* @param class-string $className
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testCreatedStub(string $className): void
{
$this->dispatcher->dispatch(
new Test\TestStubCreated(
$this->telemetryInfo(),
$className,
),
);
}
/**
* @param list<class-string> $interfaces
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testCreatedStubForIntersectionOfInterfaces(array $interfaces): void
{
$this->dispatcher->dispatch(
new Test\TestStubForIntersectionOfInterfacesCreated(
$this->telemetryInfo(),
$interfaces,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testErrored(Code\Test $test, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\Errored(
$this->telemetryInfo(),
$test,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testFailed(Code\Test $test, Throwable $throwable, ?ComparisonFailure $comparisonFailure): void
{
$this->dispatcher->dispatch(
new Test\Failed(
$this->telemetryInfo(),
$test,
$throwable,
$comparisonFailure,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testPassed(Code\Test $test): void
{
$this->dispatcher->dispatch(
new Test\Passed(
$this->telemetryInfo(),
$test,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testConsideredRisky(Code\Test $test, string $message): void
{
$this->dispatcher->dispatch(
new Test\ConsideredRisky(
$this->telemetryInfo(),
$test,
$message,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testMarkedAsIncomplete(Code\Test $test, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\MarkedIncomplete(
$this->telemetryInfo(),
$test,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testSkipped(Code\Test $test, string $message): void
{
$this->dispatcher->dispatch(
new Test\Skipped(
$this->telemetryInfo(),
$test,
$message,
),
);
}
/**
* @param non-empty-string $message
*
* @throws InvalidArgumentException
* @throws NoTestCaseObjectOnCallStackException
* @throws UnknownEventTypeException
*/
public function testTriggeredPhpunitDeprecation(?Code\Test $test, string $message): void
{
if ($test === null) {
$test = TestMethodBuilder::fromCallStack();
}
if ($test->isTestMethod()) {
assert($test instanceof TestMethod);
if ($test->metadata()->isIgnorePhpunitDeprecations()->isNotEmpty()) {
return;
}
}
$this->dispatcher->dispatch(
new Test\PhpunitDeprecationTriggered(
$this->telemetryInfo(),
$test,
$message,
),
);
}
/**
* @param non-empty-string $message
*
* @throws InvalidArgumentException
* @throws NoTestCaseObjectOnCallStackException
* @throws UnknownEventTypeException
*/
public function testTriggeredPhpunitNotice(Code\Test $test, string $message): void
{
$this->dispatcher->dispatch(
new Test\PhpunitNoticeTriggered(
$this->telemetryInfo(),
$test,
$message,
),
);
}
/**
* @param non-empty-string $message
* @param non-empty-string $file
* @param positive-int $line
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testTriggeredPhpDeprecation(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline, bool $ignoredByTest, IssueTrigger $trigger): void
{
$this->dispatcher->dispatch(
new Test\PhpDeprecationTriggered(
$this->telemetryInfo(),
$test,
$message,
$file,
$line,
$suppressed,
$ignoredByBaseline,
$ignoredByTest,
$trigger,
),
);
}
/**
* @param non-empty-string $message
* @param non-empty-string $file
* @param positive-int $line
* @param non-empty-string $stackTrace
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testTriggeredDeprecation(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline, bool $ignoredByTest, IssueTrigger $trigger, string $stackTrace): void
{
$this->dispatcher->dispatch(
new Test\DeprecationTriggered(
$this->telemetryInfo(),
$test,
$message,
$file,
$line,
$suppressed,
$ignoredByBaseline,
$ignoredByTest,
$trigger,
$stackTrace,
),
);
}
/**
* @param non-empty-string $message
* @param non-empty-string $file
* @param positive-int $line
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testTriggeredError(Code\Test $test, string $message, string $file, int $line, bool $suppressed): void
{
$this->dispatcher->dispatch(
new Test\ErrorTriggered(
$this->telemetryInfo(),
$test,
$message,
$file,
$line,
$suppressed,
),
);
}
/**
* @param non-empty-string $message
* @param non-empty-string $file
* @param positive-int $line
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testTriggeredNotice(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void
{
$this->dispatcher->dispatch(
new Test\NoticeTriggered(
$this->telemetryInfo(),
$test,
$message,
$file,
$line,
$suppressed,
$ignoredByBaseline,
),
);
}
/**
* @param non-empty-string $message
* @param non-empty-string $file
* @param positive-int $line
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testTriggeredPhpNotice(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void
{
$this->dispatcher->dispatch(
new Test\PhpNoticeTriggered(
$this->telemetryInfo(),
$test,
$message,
$file,
$line,
$suppressed,
$ignoredByBaseline,
),
);
}
/**
* @param non-empty-string $message
* @param non-empty-string $file
* @param positive-int $line
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testTriggeredWarning(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void
{
$this->dispatcher->dispatch(
new Test\WarningTriggered(
$this->telemetryInfo(),
$test,
$message,
$file,
$line,
$suppressed,
$ignoredByBaseline,
),
);
}
/**
* @param non-empty-string $message
* @param non-empty-string $file
* @param positive-int $line
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testTriggeredPhpWarning(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void
{
$this->dispatcher->dispatch(
new Test\PhpWarningTriggered(
$this->telemetryInfo(),
$test,
$message,
$file,
$line,
$suppressed,
$ignoredByBaseline,
),
);
}
/**
* @param non-empty-string $message
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testTriggeredPhpunitError(Code\Test $test, string $message): void
{
$this->dispatcher->dispatch(
new Test\PhpunitErrorTriggered(
$this->telemetryInfo(),
$test,
$message,
),
);
}
/**
* @param non-empty-string $message
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testTriggeredPhpunitWarning(Code\Test $test, string $message): void
{
$ignoredByTest = false;
if ($test->isTestMethod()) {
assert($test instanceof TestMethod);
$metadata = Registry::parser()->forMethod($test->className(), $test->methodName())->isIgnorePhpunitWarnings()->asArray();
if (isset($metadata[0])) {
assert($metadata[0] instanceof IgnorePhpunitWarnings);
$messagePattern = $metadata[0]->messagePattern();
if ($messagePattern === null || (bool) preg_match('{' . $messagePattern . '}', $message)) {
$ignoredByTest = true;
}
}
}
$this->dispatcher->dispatch(
new Test\PhpunitWarningTriggered(
$this->telemetryInfo(),
$test,
$message,
$ignoredByTest,
),
);
}
/**
* @param non-empty-string $output
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testPrintedUnexpectedOutput(string $output): void
{
$this->dispatcher->dispatch(
new Test\PrintedUnexpectedOutput(
$this->telemetryInfo(),
$output,
),
);
}
/**
* @param non-empty-string $additionalInformation
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testProvidedAdditionalInformation(TestMethod $test, string $additionalInformation): void
{
$this->dispatcher->dispatch(
new Test\AdditionalInformationProvided(
$this->telemetryInfo(),
$test,
$additionalInformation,
),
);
}
/**
* @param non-negative-int $numberOfAssertionsPerformed
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testFinished(Code\Test $test, int $numberOfAssertionsPerformed): void
{
$this->dispatcher->dispatch(
new Test\Finished(
$this->telemetryInfo(),
$test,
$numberOfAssertionsPerformed,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function postConditionCalled(TestMethod $test, ClassMethod $calledMethod): void
{
$this->dispatcher->dispatch(
new Test\PostConditionCalled(
$this->telemetryInfo(),
$test,
$calledMethod,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function postConditionErrored(TestMethod $test, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\PostConditionErrored(
$this->telemetryInfo(),
$test,
$calledMethod,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function postConditionFailed(TestMethod $test, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\PostConditionFailed(
$this->telemetryInfo(),
$test,
$calledMethod,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function postConditionFinished(TestMethod $test, ClassMethod ...$calledMethods): void
{
$this->dispatcher->dispatch(
new Test\PostConditionFinished(
$this->telemetryInfo(),
$test,
...$calledMethods,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function afterTestMethodCalled(TestMethod $test, ClassMethod $calledMethod): void
{
$this->dispatcher->dispatch(
new Test\AfterTestMethodCalled(
$this->telemetryInfo(),
$test,
$calledMethod,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function afterTestMethodErrored(TestMethod $test, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\AfterTestMethodErrored(
$this->telemetryInfo(),
$test,
$calledMethod,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function afterTestMethodFailed(TestMethod $test, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\AfterTestMethodFailed(
$this->telemetryInfo(),
$test,
$calledMethod,
$throwable,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function afterTestMethodFinished(TestMethod $test, ClassMethod ...$calledMethods): void
{
$this->dispatcher->dispatch(
new Test\AfterTestMethodFinished(
$this->telemetryInfo(),
$test,
...$calledMethods,
),
);
}
/**
* @param class-string<TestCase> $testClassName
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function afterLastTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void
{
$this->dispatcher->dispatch(
new Test\AfterLastTestMethodCalled(
$this->telemetryInfo(),
$testClassName,
$calledMethod,
),
);
}
/**
* @param class-string<TestCase> $testClassName
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function afterLastTestMethodErrored(string $testClassName, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\AfterLastTestMethodErrored(
$this->telemetryInfo(),
$testClassName,
$calledMethod,
$throwable,
),
);
}
/**
* @param class-string<TestCase> $testClassName
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function afterLastTestMethodFailed(string $testClassName, ClassMethod $calledMethod, Throwable $throwable): void
{
$this->dispatcher->dispatch(
new Test\AfterLastTestMethodFailed(
$this->telemetryInfo(),
$testClassName,
$calledMethod,
$throwable,
),
);
}
/**
* @param class-string<TestCase> $testClassName
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function afterLastTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void
{
$this->dispatcher->dispatch(
new Test\AfterLastTestMethodFinished(
$this->telemetryInfo(),
$testClassName,
...$calledMethods,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testSuiteFinished(TestSuite $testSuite): void
{
$this->dispatcher->dispatch(
new TestSuiteFinished(
$this->telemetryInfo(),
$testSuite,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerStartedStaticAnalysisForCodeCoverage(): void
{
$this->dispatcher->dispatch(
new TestRunner\StaticAnalysisForCodeCoverageStarted(
$this->telemetryInfo(),
),
);
}
/**
* @param non-negative-int $cacheHits
* @param non-negative-int $cacheMisses
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerFinishedStaticAnalysisForCodeCoverage(int $cacheHits, int $cacheMisses): void
{
$this->dispatcher->dispatch(
new TestRunner\StaticAnalysisForCodeCoverageFinished(
$this->telemetryInfo(),
$cacheHits,
$cacheMisses,
),
);
}
/**
* @param non-empty-string $message
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerTriggeredPhpunitDeprecation(string $message): void
{
try {
if (TestMethodBuilder::fromCallStack()->metadata()->isIgnorePhpunitDeprecations()->isNotEmpty()) {
return;
}
} catch (NoTestCaseObjectOnCallStackException) {
}
$this->dispatcher->dispatch(
new TestRunner\DeprecationTriggered(
$this->telemetryInfo(),
$message,
),
);
}
/**
* @param non-empty-string $message
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerTriggeredPhpunitNotice(string $message): void
{
$this->dispatcher->dispatch(
new TestRunner\NoticeTriggered(
$this->telemetryInfo(),
$message,
),
);
}
/**
* @param non-empty-string $message
*
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerTriggeredPhpunitWarning(string $message): void
{
$this->dispatcher->dispatch(
new TestRunner\WarningTriggered(
$this->telemetryInfo(),
$message,
),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerEnabledGarbageCollection(): void
{
$this->dispatcher->dispatch(
new TestRunner\GarbageCollectionEnabled($this->telemetryInfo()),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerExecutionAborted(): void
{
$this->dispatcher->dispatch(
new TestRunner\ExecutionAborted($this->telemetryInfo()),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerExecutionFinished(): void
{
$this->dispatcher->dispatch(
new TestRunner\ExecutionFinished($this->telemetryInfo()),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function testRunnerFinished(): void
{
$this->dispatcher->dispatch(
new TestRunner\Finished($this->telemetryInfo()),
);
}
/**
* @throws InvalidArgumentException
* @throws UnknownEventTypeException
*/
public function applicationFinished(int $shellExitCode): void
{
$this->dispatcher->dispatch(
new Application\Finished(
$this->telemetryInfo(),
$shellExitCode,
),
);
}
/**
* @throws InvalidArgumentException
*/
private function telemetryInfo(): Telemetry\Info
{
$current = $this->system->snapshot();
$info = new Telemetry\Info(
$current,
$current->time()->duration($this->startSnapshot->time()),
$current->memoryUsage()->diff($this->startSnapshot->memoryUsage()),
$current->time()->duration($this->previousSnapshot->time()),
$current->memoryUsage()->diff($this->previousSnapshot->memoryUsage()),
);
$this->previousSnapshot = $current;
return $info;
}
}