.gitattributes

@@ -0,0 +1,4 @@
+/Tests export-ignore
+/phpunit.xml.dist export-ignore
+/.gitattributes export-ignore
+/.gitignore export-ignore

CHANGELOG.md

@@ -1,6 +1,48 @@
 CHANGELOG
 =========
 
+6.4
+---
+
+ * Allow setting the locale using `SYMFONY_PHPUNIT_LOCALE` env var
+
+6.3
+---
+
+ * Add support for mocking the `enum_exists` function
+ * Enable reporting of deprecations triggered by Doctrine by default
+
+6.2
+---
+
+ * Add support for mocking the `hrtime()` function
+
+6.1
+---
+
+ * Add option `ignoreFile` to configure a file that lists deprecation messages to ignore
+
+6.0
+---
+
+ * Remove `SetUpTearDownTrait`
+
+5.3
+---
+
+ * bumped the minimum PHP version to 7.1.3
+ * bumped the minimum PHPUnit version to 7.5
+ * deprecated the `SetUpTearDownTrait` trait, use original methods with "void" return typehint.
+ * added `logFile` option to write deprecations to a file instead of echoing them
+
+5.1.0
+-----
+
+ * ignore verbosity settings when the build fails because of deprecations
+ * added per-group verbosity
+ * added `ExpectDeprecationTrait` to be able to define an expected deprecation from inside a test
+ * deprecated the `@expectedDeprecation` annotation, use the `ExpectDeprecationTrait::expectDeprecation()` method instead
+
 5.0.0
 -----
 
@@ -17,7 +59,7 @@ CHANGELOG
 -----
 
  * added `ClassExistsMock`
- * bumped PHP version from 5.3.3 to 5.5.9 
+ * bumped PHP version from 5.3.3 to 5.5.9
  * split simple-phpunit bin into php file with code and a shell script
 
 4.1.0

ClassExistsMock.php

@@ -18,34 +18,60 @@ class ClassExistsMock
 {
     private static $classes = [];
 
+    private static $enums = [];
+
     /**
      * Configures the classes to be checked upon existence.
      *
-     * @param array $classes Mocked class names as keys (case sensitive, without leading root namespace slash) and booleans as values
+     * @param array $classes Mocked class names as keys (case-sensitive, without leading root namespace slash) and booleans as values
      */
-    public static function withMockedClasses(array $classes)
+    public static function withMockedClasses(array $classes): void
     {
         self::$classes = $classes;
     }
 
-    public static function class_exists($name, $autoload = true)
+    /**
+     * Configures the enums to be checked upon existence.
+     *
+     * @param array $enums Mocked enums names as keys (case-sensitive, without leading root namespace slash) and booleans as values
+     */
+    public static function withMockedEnums(array $enums): void
+    {
+        self::$enums = $enums;
+        self::$classes += $enums;
+    }
+
+    public static function class_exists($name, $autoload = true): bool
     {
-        return (bool) (self::$classes[ltrim($name, '\\')] ?? \class_exists($name, $autoload));
+        $name = ltrim($name, '\\');
+
+        return isset(self::$classes[$name]) ? (bool) self::$classes[$name] : \class_exists($name, $autoload);
     }
 
-    public static function interface_exists($name, $autoload = true)
+    public static function interface_exists($name, $autoload = true): bool
     {
-        return (bool) (self::$classes[ltrim($name, '\\')] ?? \interface_exists($name, $autoload));
+        $name = ltrim($name, '\\');
+
+        return isset(self::$classes[$name]) ? (bool) self::$classes[$name] : \interface_exists($name, $autoload);
     }
 
-    public static function trait_exists($name, $autoload = true)
+    public static function trait_exists($name, $autoload = true): bool
     {
-        return (bool) (self::$classes[ltrim($name, '\\')] ?? \trait_exists($name, $autoload));
+        $name = ltrim($name, '\\');
+
+        return isset(self::$classes[$name]) ? (bool) self::$classes[$name] : \trait_exists($name, $autoload);
+    }
+
+    public static function enum_exists($name, $autoload = true):bool
+    {
+        $name = ltrim($name, '\\');
+
+        return isset(self::$enums[$name]) ? (bool) self::$enums[$name] : \enum_exists($name, $autoload);
     }
 
-    public static function register($class)
+    public static function register($class): void
     {
-        $self = \get_called_class();
+        $self = static::class;
 
         $mockedNs = [substr($class, 0, strrpos($class, '\\'))];
         if (0 < strpos($class, '\\Tests\\')) {
@@ -55,7 +81,7 @@ public static function register($class)
             $mockedNs[] = substr($class, 6, strrpos($class, '\\') - 6);
         }
         foreach ($mockedNs as $ns) {
-            foreach (['class', 'interface', 'trait'] as $type) {
+            foreach (['class', 'interface', 'trait', 'enum'] as $type) {
                 if (\function_exists($ns.'\\'.$type.'_exists')) {
                     continue;
                 }

ClockMock.php

@@ -19,7 +19,7 @@ class ClockMock
 {
     private static $now;
 
-    public static function withClockMock($enable = null)
+    public static function withClockMock($enable = null): ?bool
     {
         if (null === $enable) {
             return null !== self::$now;
@@ -30,7 +30,7 @@ public static function withClockMock($enable = null)
         return null;
     }
 
-    public static function time()
+    public static function time(): int
     {
         if (null === self::$now) {
             return \time();
@@ -39,7 +39,7 @@ public static function time()
         return (int) self::$now;
     }
 
-    public static function sleep($s)
+    public static function sleep($s): int
     {
         if (null === self::$now) {
             return \sleep($s);
@@ -50,7 +50,7 @@ public static function sleep($s)
         return 0;
     }
 
-    public static function usleep($us)
+    public static function usleep($us): void
     {
         if (null === self::$now) {
             \usleep($us);
@@ -59,6 +59,9 @@ public static function usleep($us)
         }
     }
 
+    /**
+     * @return string|float
+     */
     public static function microtime($asFloat = false)
     {
         if (null === self::$now) {
@@ -72,7 +75,7 @@ public static function microtime($asFloat = false)
         return sprintf('%0.6f00 %d', self::$now - (int) self::$now, (int) self::$now);
     }
 
-    public static function date($format, $timestamp = null)
+    public static function date($format, $timestamp = null): string
     {
         if (null === $timestamp) {
             $timestamp = self::time();
@@ -81,7 +84,7 @@ public static function date($format, $timestamp = null)
         return \date($format, $timestamp);
     }
 
-    public static function gmdate($format, $timestamp = null)
+    public static function gmdate($format, $timestamp = null): string
     {
         if (null === $timestamp) {
             $timestamp = self::time();
@@ -90,9 +93,25 @@ public static function gmdate($format, $timestamp = null)
         return \gmdate($format, $timestamp);
     }
 
-    public static function register($class)
+    /**
+     * @return array|int|float
+     */
+    public static function hrtime($asNumber = false)
     {
-        $self = \get_called_class();
+        $ns = (self::$now - (int) self::$now) * 1000000000;
+
+        if ($asNumber) {
+            $number = sprintf('%d%d', (int) self::$now, $ns);
+
+            return \PHP_INT_SIZE === 8 ? (int) $number : (float) $number;
+        }
+
+        return [(int) self::$now, (int) $ns];
+    }
+
+    public static function register($class): void
+    {
+        $self = static::class;
 
         $mockedNs = [substr($class, 0, strrpos($class, '\\'))];
         if (0 < strpos($class, '\\Tests\\')) {
@@ -137,6 +156,11 @@ function gmdate(\$format, \$timestamp = null)
 {
     return \\$self::gmdate(\$format, \$timestamp);
 }
+
+function hrtime(\$asNumber = false)
+{
+    return \\$self::hrtime(\$asNumber);
+}
 EOPHP
             );
         }

ConstraintTrait.php

@@ -12,17 +12,21 @@
 namespace Symfony\Bridge\PhpUnit;
 
 use PHPUnit\Framework\Constraint\Constraint;
-use ReflectionClass;
 
-$r = new ReflectionClass(Constraint::class);
-if (\PHP_VERSION_ID < 70000 || !$r->getMethod('matches')->hasReturnType()) {
+$r = new \ReflectionClass(Constraint::class);
+if ($r->getProperty('exporter')->isProtected()) {
     trait ConstraintTrait
     {
-        use Legacy\ConstraintTraitForV6;
+        use Legacy\ConstraintTraitForV7;
+    }
+} elseif (!$r->getMethod('evaluate')->hasReturnType()) {
+    trait ConstraintTrait
+    {
+        use Legacy\ConstraintTraitForV8;
     }
 } else {
     trait ConstraintTrait
     {
-        use Legacy\ConstraintTraitForV7;
+        use Legacy\ConstraintTraitForV9;
     }
 }

CoverageListener.php

@@ -11,16 +11,109 @@
 
 namespace Symfony\Bridge\PhpUnit;
 
-if (version_compare(\PHPUnit\Runner\Version::id(), '6.0.0', '<')) {
-    class_alias('Symfony\Bridge\PhpUnit\Legacy\CoverageListenerForV5', 'Symfony\Bridge\PhpUnit\CoverageListener');
-} elseif (version_compare(\PHPUnit\Runner\Version::id(), '7.0.0', '<')) {
-    class_alias('Symfony\Bridge\PhpUnit\Legacy\CoverageListenerForV6', 'Symfony\Bridge\PhpUnit\CoverageListener');
-} else {
-    class_alias('Symfony\Bridge\PhpUnit\Legacy\CoverageListenerForV7', 'Symfony\Bridge\PhpUnit\CoverageListener');
-}
+use PHPUnit\Framework\Test;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\TestListener;
+use PHPUnit\Framework\TestListenerDefaultImplementation;
+use PHPUnit\Framework\Warning;
+use PHPUnit\Util\Annotation\Registry;
+use PHPUnit\Util\Test as TestUtil;
+
+class CoverageListener implements TestListener
+{
+    use TestListenerDefaultImplementation;
+
+    private $sutFqcnResolver;
+    private $warningOnSutNotFound;
+
+    public function __construct(?callable $sutFqcnResolver = null, bool $warningOnSutNotFound = false)
+    {
+        $this->sutFqcnResolver = $sutFqcnResolver ?? static function (Test $test): ?string {
+            $class = \get_class($test);
+
+            $sutFqcn = str_replace('\\Tests\\', '\\', $class);
+            $sutFqcn = preg_replace('{Test$}', '', $sutFqcn);
+
+            return class_exists($sutFqcn) ? $sutFqcn : null;
+        };
+
+        $this->warningOnSutNotFound = $warningOnSutNotFound;
+    }
+
+    public function startTest(Test $test): void
+    {
+        if (!$test instanceof TestCase) {
+            return;
+        }
+
+        $annotations = TestUtil::parseTestMethodAnnotations(\get_class($test), $test->getName(false));
+
+        $ignoredAnnotations = ['covers', 'coversDefaultClass', 'coversNothing'];
+
+        foreach ($ignoredAnnotations as $annotation) {
+            if (isset($annotations['class'][$annotation]) || isset($annotations['method'][$annotation])) {
+                return;
+            }
+        }
+
+        $sutFqcn = ($this->sutFqcnResolver)($test);
+        if (!$sutFqcn) {
+            if ($this->warningOnSutNotFound) {
+                $test->getTestResultObject()->addWarning($test, new Warning('Could not find the tested class.'), 0);
+            }
 
-if (false) {
-    class CoverageListener
+            return;
+        }
+
+        $covers = $sutFqcn;
+        if (!\is_array($sutFqcn)) {
+            $covers = [$sutFqcn];
+            while ($parent = get_parent_class($sutFqcn)) {
+                $covers[] = $parent;
+                $sutFqcn = $parent;
+            }
+        }
+
+        if (class_exists(Registry::class)) {
+            $this->addCoversForDocBlockInsideRegistry($test, $covers);
+
+            return;
+        }
+
+        $this->addCoversForClassToAnnotationCache($test, $covers);
+    }
+
+    private function addCoversForClassToAnnotationCache(Test $test, array $covers): void
     {
+        $r = new \ReflectionProperty(TestUtil::class, 'annotationCache');
+        $r->setAccessible(true);
+
+        $cache = $r->getValue();
+        $cache = array_replace_recursive($cache, [
+            \get_class($test) => [
+                'covers' => $covers,
+            ],
+        ]);
+
+        $r->setValue(TestUtil::class, $cache);
+    }
+
+    private function addCoversForDocBlockInsideRegistry(Test $test, array $covers): void
+    {
+        $docBlock = Registry::getInstance()->forClassName(\get_class($test));
+
+        $symbolAnnotations = new \ReflectionProperty($docBlock, 'symbolAnnotations');
+        $symbolAnnotations->setAccessible(true);
+
+        // Exclude internal classes; PHPUnit 9.1+ is picky about tests covering, say, a \RuntimeException
+        $covers = array_filter($covers, function (string $class) {
+            $reflector = new \ReflectionClass($class);
+
+            return $reflector->isUserDefined();
+        });
+
+        $symbolAnnotations->setValue($docBlock, array_replace($docBlock->symbolAnnotations(), [
+            'covers' => $covers,
+        ]));
     }
 }