[Debug] Skip a test that was meant for HHVM.

Debug.php

@@ -28,7 +28,7 @@ class Debug
      * @param int  $errorReportingLevel The level of error reporting you want
      * @param bool $displayErrors       Whether to display errors (for development) or just log them (for production)
      */
-    public static function enable($errorReportingLevel = E_ALL, $displayErrors = true)
+    public static function enable($errorReportingLevel = \E_ALL, $displayErrors = true)
     {
         if (static::$enabled) {
             return;
@@ -39,13 +39,13 @@ class Debug
         if (null !== $errorReportingLevel) {
             error_reporting($errorReportingLevel);
         } else {
-            error_reporting(E_ALL);
+            error_reporting(\E_ALL);
         }
 
         if (!\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true)) {
             ini_set('display_errors', 0);
             ExceptionHandler::register();
-        } elseif ($displayErrors && (!filter_var(ini_get('log_errors'), FILTER_VALIDATE_BOOLEAN) || ini_get('error_log'))) {
+        } elseif ($displayErrors && (!filter_var(ini_get('log_errors'), \FILTER_VALIDATE_BOOLEAN) || ini_get('error_log'))) {
             // CLI - display errors only if they're not already logged to STDERR
             ini_set('display_errors', 1);
         }

DebugClassLoader.php

@@ -56,7 +56,7 @@ class DebugClassLoader
             } elseif (substr($test, -\strlen($file)) === $file) {
                 // filesystem is case insensitive and realpath() normalizes the case of characters
                 self::$caseCheck = 1;
-            } elseif (false !== stripos(PHP_OS, 'darwin')) {
+            } elseif (false !== stripos(\PHP_OS, 'darwin')) {
                 // on MacOSX, HFS+ is case insensitive but realpath() doesn't normalize the case of characters
                 self::$caseCheck = 2;
             } else {
@@ -141,7 +141,7 @@ class DebugClassLoader
      */
     public function loadClass($class)
     {
-        $e = error_reporting(error_reporting() | E_PARSE | E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR);
+        $e = error_reporting(error_reporting() | \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR);
 
         try {
             if ($this->isFinder && !isset($this->loaded[$class])) {
@@ -197,7 +197,7 @@ class DebugClassLoader
             }
 
             foreach ($deprecations as $message) {
-                @trigger_error($message, E_USER_DEPRECATED);
+                @trigger_error($message, \E_USER_DEPRECATED);
             }
         }
 

ErrorHandler.php

@@ -49,39 +49,39 @@ use Symfony\Component\Debug\FatalErrorHandler\UndefinedMethodFatalErrorHandler;
 class ErrorHandler
 {
     private $levels = [
-        E_DEPRECATED => 'Deprecated',
-        E_USER_DEPRECATED => 'User Deprecated',
-        E_NOTICE => 'Notice',
-        E_USER_NOTICE => 'User Notice',
-        E_STRICT => 'Runtime Notice',
-        E_WARNING => 'Warning',
-        E_USER_WARNING => 'User Warning',
-        E_COMPILE_WARNING => 'Compile Warning',
-        E_CORE_WARNING => 'Core Warning',
-        E_USER_ERROR => 'User Error',
-        E_RECOVERABLE_ERROR => 'Catchable Fatal Error',
-        E_COMPILE_ERROR => 'Compile Error',
-        E_PARSE => 'Parse Error',
-        E_ERROR => 'Error',
-        E_CORE_ERROR => 'Core Error',
+        \E_DEPRECATED => 'Deprecated',
+        \E_USER_DEPRECATED => 'User Deprecated',
+        \E_NOTICE => 'Notice',
+        \E_USER_NOTICE => 'User Notice',
+        \E_STRICT => 'Runtime Notice',
+        \E_WARNING => 'Warning',
+        \E_USER_WARNING => 'User Warning',
+        \E_COMPILE_WARNING => 'Compile Warning',
+        \E_CORE_WARNING => 'Core Warning',
+        \E_USER_ERROR => 'User Error',
+        \E_RECOVERABLE_ERROR => 'Catchable Fatal Error',
+        \E_COMPILE_ERROR => 'Compile Error',
+        \E_PARSE => 'Parse Error',
+        \E_ERROR => 'Error',
+        \E_CORE_ERROR => 'Core Error',
     ];
 
     private $loggers = [
-        E_DEPRECATED => [null, LogLevel::INFO],
-        E_USER_DEPRECATED => [null, LogLevel::INFO],
-        E_NOTICE => [null, LogLevel::WARNING],
-        E_USER_NOTICE => [null, LogLevel::WARNING],
-        E_STRICT => [null, LogLevel::WARNING],
-        E_WARNING => [null, LogLevel::WARNING],
-        E_USER_WARNING => [null, LogLevel::WARNING],
-        E_COMPILE_WARNING => [null, LogLevel::WARNING],
-        E_CORE_WARNING => [null, LogLevel::WARNING],
-        E_USER_ERROR => [null, LogLevel::CRITICAL],
-        E_RECOVERABLE_ERROR => [null, LogLevel::CRITICAL],
-        E_COMPILE_ERROR => [null, LogLevel::CRITICAL],
-        E_PARSE => [null, LogLevel::CRITICAL],
-        E_ERROR => [null, LogLevel::CRITICAL],
-        E_CORE_ERROR => [null, LogLevel::CRITICAL],
+        \E_DEPRECATED => [null, LogLevel::INFO],
+        \E_USER_DEPRECATED => [null, LogLevel::INFO],
+        \E_NOTICE => [null, LogLevel::WARNING],
+        \E_USER_NOTICE => [null, LogLevel::WARNING],
+        \E_STRICT => [null, LogLevel::WARNING],
+        \E_WARNING => [null, LogLevel::WARNING],
+        \E_USER_WARNING => [null, LogLevel::WARNING],
+        \E_COMPILE_WARNING => [null, LogLevel::WARNING],
+        \E_CORE_WARNING => [null, LogLevel::WARNING],
+        \E_USER_ERROR => [null, LogLevel::CRITICAL],
+        \E_RECOVERABLE_ERROR => [null, LogLevel::CRITICAL],
+        \E_COMPILE_ERROR => [null, LogLevel::CRITICAL],
+        \E_PARSE => [null, LogLevel::CRITICAL],
+        \E_ERROR => [null, LogLevel::CRITICAL],
+        \E_CORE_ERROR => [null, LogLevel::CRITICAL],
     ];
 
     private $thrownErrors = 0x1FFF; // E_ALL - E_DEPRECATED - E_USER_DEPRECATED
@@ -154,7 +154,7 @@ class ErrorHandler
             $handler->setExceptionHandler($prev);
         }
 
-        $handler->throwAt(E_ALL & $handler->thrownErrors, true);
+        $handler->throwAt(\E_ALL & $handler->thrownErrors, true);
 
         return $handler;
     }
@@ -176,7 +176,7 @@ class ErrorHandler
      * @param array|int       $levels  An array map of E_* to LogLevel::* or an integer bit field of E_* constants
      * @param bool            $replace Whether to replace or not any existing logger
      */
-    public function setDefaultLogger(LoggerInterface $logger, $levels = E_ALL, $replace = false)
+    public function setDefaultLogger(LoggerInterface $logger, $levels = \E_ALL, $replace = false)
     {
         $loggers = [];
 
@@ -188,7 +188,7 @@ class ErrorHandler
             }
         } else {
             if (null === $levels) {
-                $levels = E_ALL;
+                $levels = \E_ALL;
             }
             foreach ($this->loggers as $type => $log) {
                 if (($type & $levels) && (empty($log[0]) || $replace || $log[0] === $this->bootstrappingLogger)) {
@@ -242,7 +242,7 @@ class ErrorHandler
 
         if ($flush) {
             foreach ($this->bootstrappingLogger->cleanLogs() as $log) {
-                $type = $log[2]['exception'] instanceof \ErrorException ? $log[2]['exception']->getSeverity() : E_ERROR;
+                $type = $log[2]['exception'] instanceof \ErrorException ? $log[2]['exception']->getSeverity() : \E_ERROR;
                 if (!isset($flush[$type])) {
                     $this->bootstrappingLogger->log($log[0], $log[1], $log[2]);
                 } elseif ($this->loggers[$type][0]) {
@@ -280,7 +280,7 @@ class ErrorHandler
     public function throwAt($levels, $replace = false)
     {
         $prev = $this->thrownErrors;
-        $this->thrownErrors = ($levels | E_RECOVERABLE_ERROR | E_USER_ERROR) & ~E_USER_DEPRECATED & ~E_DEPRECATED;
+        $this->thrownErrors = ($levels | \E_RECOVERABLE_ERROR | \E_USER_ERROR) & ~\E_USER_DEPRECATED & ~\E_DEPRECATED;
         if (!$replace) {
             $this->thrownErrors |= $prev;
         }
@@ -382,15 +382,15 @@ class ErrorHandler
      */
     public function handleError($type, $message, $file, $line)
     {
-        if (\PHP_VERSION_ID >= 70300 && E_WARNING === $type && '"' === $message[0] && false !== strpos($message, '" targeting switch is equivalent to "break')) {
-            $type = E_DEPRECATED;
+        if (\PHP_VERSION_ID >= 70300 && \E_WARNING === $type && '"' === $message[0] && false !== strpos($message, '" targeting switch is equivalent to "break')) {
+            $type = \E_DEPRECATED;
         }
 
         // Level is the current error reporting level to manage silent error.
         $level = error_reporting();
         $silenced = 0 === ($level & $type);
         // Strong errors are not authorized to be silenced.
-        $level |= E_RECOVERABLE_ERROR | E_USER_ERROR | E_DEPRECATED | E_USER_DEPRECATED;
+        $level |= \E_RECOVERABLE_ERROR | \E_USER_ERROR | \E_DEPRECATED | \E_USER_DEPRECATED;
         $log = $this->loggedErrors & $type;
         $throw = $this->thrownErrors & $type & $level;
         $type &= $level | $this->screamedErrors;
@@ -414,7 +414,7 @@ class ErrorHandler
             $context = $e;
         }
 
-        if (null !== $backtrace && $type & E_ERROR) {
+        if (null !== $backtrace && $type & \E_ERROR) {
             // E_ERROR fatal errors are triggered on HHVM when
             // hhvm.error_handling.call_user_handler_on_fatals=1
             // which is the way to get their backtrace.
@@ -430,7 +430,7 @@ class ErrorHandler
             self::$toStringException = null;
         } elseif (!$throw && !($type & $level)) {
             if (!isset(self::$silencedErrorCache[$id = $file.':'.$line])) {
-                $lightTrace = $this->tracedErrors & $type ? $this->cleanTrace(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3), $type, $file, $line, false) : [];
+                $lightTrace = $this->tracedErrors & $type ? $this->cleanTrace(debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 3), $type, $file, $line, false) : [];
                 $errorAsException = new SilencedErrorContext($type, $file, $line, $lightTrace);
             } elseif (isset(self::$silencedErrorCache[$id][$message])) {
                 $lightTrace = null;
@@ -469,7 +469,7 @@ class ErrorHandler
         }
 
         if ($throw) {
-            if (\PHP_VERSION_ID < 70400 && E_USER_ERROR & $type) {
+            if (\PHP_VERSION_ID < 70400 && \E_USER_ERROR & $type) {
                 for ($i = 1; isset($backtrace[$i]); ++$i) {
                     if (isset($backtrace[$i]['function'], $backtrace[$i]['type'], $backtrace[$i - 1]['function'])
                         && '__toString' === $backtrace[$i]['function']
@@ -558,7 +558,7 @@ class ErrorHandler
         if (!$exception instanceof \Exception) {
             $exception = new FatalThrowableError($exception);
         }
-        $type = $exception instanceof FatalErrorException ? $exception->getSeverity() : E_ERROR;
+        $type = $exception instanceof FatalErrorException ? $exception->getSeverity() : \E_ERROR;
         $handlerException = null;
 
         if (($this->loggedErrors & $type) || $exception instanceof FatalThrowableError) {
@@ -674,7 +674,7 @@ class ErrorHandler
             // Handled below
         }
 
-        if ($error && $error['type'] &= E_PARSE | E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR) {
+        if ($error && $error['type'] &= \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR) {
             // Let's not throw anymore but keep logging
             $handler->throwAt(0, true);
             $trace = isset($error['backtrace']) ? $error['backtrace'] : null;
@@ -716,9 +716,9 @@ class ErrorHandler
      */
     public static function stackErrors()
     {
-        @trigger_error('Support for stacking errors is deprecated since Symfony 3.4 and will be removed in 4.0.', E_USER_DEPRECATED);
+        @trigger_error('Support for stacking errors is deprecated since Symfony 3.4 and will be removed in 4.0.', \E_USER_DEPRECATED);
 
-        self::$stackedErrorLevels[] = error_reporting(error_reporting() | E_PARSE | E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR);
+        self::$stackedErrorLevels[] = error_reporting(error_reporting() | \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR);
     }
 
     /**
@@ -728,13 +728,13 @@ class ErrorHandler
      */
     public static function unstackErrors()
     {
-        @trigger_error('Support for unstacking errors is deprecated since Symfony 3.4 and will be removed in 4.0.', E_USER_DEPRECATED);
+        @trigger_error('Support for unstacking errors is deprecated since Symfony 3.4 and will be removed in 4.0.', \E_USER_DEPRECATED);
 
         $level = array_pop(self::$stackedErrorLevels);
 
         if (null !== $level) {
             $errorReportingLevel = error_reporting($level);
-            if ($errorReportingLevel !== ($level | E_PARSE | E_ERROR | E_CORE_ERROR | E_COMPILE_ERROR)) {
+            if ($errorReportingLevel !== ($level | \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR)) {
                 // If the user changed the error level, do not overwrite it
                 error_reporting($errorReportingLevel);
             }

Exception/ContextErrorException.php

@@ -33,7 +33,7 @@ class ContextErrorException extends \ErrorException
      */
     public function getContext()
     {
-        @trigger_error(sprintf('The %s class is deprecated since Symfony 3.3 and will be removed in 4.0.', __CLASS__), E_USER_DEPRECATED);
+        @trigger_error(sprintf('The %s class is deprecated since Symfony 3.3 and will be removed in 4.0.', __CLASS__), \E_USER_DEPRECATED);
 
         return $this->context;
     }

Exception/FatalThrowableError.php

@@ -22,13 +22,13 @@ class FatalThrowableError extends FatalErrorException
     {
         if ($e instanceof \ParseError) {
             $message = 'Parse error: '.$e->getMessage();
-            $severity = E_PARSE;
+            $severity = \E_PARSE;
         } elseif ($e instanceof \TypeError) {
             $message = 'Type error: '.$e->getMessage();
-            $severity = E_RECOVERABLE_ERROR;
+            $severity = \E_RECOVERABLE_ERROR;
         } else {
             $message = $e->getMessage();
-            $severity = E_ERROR;
+            $severity = \E_ERROR;
         }
 
         \ErrorException::__construct(

ExceptionHandler.php

@@ -377,7 +377,7 @@ EOF;
 
         if (\is_string($fmt)) {
             $i = strpos($f = $fmt, '&', max(strrpos($f, '%f'), strrpos($f, '%l'))) ?: \strlen($f);
-            $fmt = [substr($f, 0, $i)] + preg_split('/&([^>]++)>/', substr($f, $i), -1, PREG_SPLIT_DELIM_CAPTURE);
+            $fmt = [substr($f, 0, $i)] + preg_split('/&([^>]++)>/', substr($f, $i), -1, \PREG_SPLIT_DELIM_CAPTURE);
 
             for ($i = 1; isset($fmt[$i]); ++$i) {
                 if (0 === strpos($path, $k = $fmt[$i++])) {
@@ -434,7 +434,7 @@ EOF;
      */
     private function escapeHtml($str)
     {
-        return htmlspecialchars($str, ENT_COMPAT | ENT_SUBSTITUTE, $this->charset);
+        return htmlspecialchars($str, \ENT_COMPAT | \ENT_SUBSTITUTE, $this->charset);
     }
 
     private function getSymfonyGhostAsSvg()

FatalErrorHandler/ClassNotFoundFatalErrorHandler.php

@@ -29,50 +29,34 @@ class ClassNotFoundFatalErrorHandler implements FatalErrorHandlerInterface
      */
     public function handleError(array $error, FatalErrorException $exception)
     {
-        $messageLen = \strlen($error['message']);
-        $notFoundSuffix = '\' not found';
-        $notFoundSuffixLen = \strlen($notFoundSuffix);
-        if ($notFoundSuffixLen > $messageLen) {
+        if (!preg_match('/^(Class|Interface|Trait) [\'"]([^\'"]+)[\'"] not found$/', $error['message'], $matches)) {
             return null;
         }
+        $typeName = strtolower($matches[1]);
+        $fullyQualifiedClassName = $matches[2];
 
-        if (0 !== substr_compare($error['message'], $notFoundSuffix, -$notFoundSuffixLen)) {
-            return null;
+        if (false !== $namespaceSeparatorIndex = strrpos($fullyQualifiedClassName, '\\')) {
+            $className = substr($fullyQualifiedClassName, $namespaceSeparatorIndex + 1);
+            $namespacePrefix = substr($fullyQualifiedClassName, 0, $namespaceSeparatorIndex);
+            $message = sprintf('Attempted to load %s "%s" from namespace "%s".', $typeName, $className, $namespacePrefix);
+            $tail = ' for another namespace?';
+        } else {
+            $className = $fullyQualifiedClassName;
+            $message = sprintf('Attempted to load %s "%s" from the global namespace.', $typeName, $className);
+            $tail = '?';
         }
 
-        foreach (['class', 'interface', 'trait'] as $typeName) {
-            $prefix = ucfirst($typeName).' \'';
-            $prefixLen = \strlen($prefix);
-            if (0 !== strpos($error['message'], $prefix)) {
-                continue;
-            }
-
-            $fullyQualifiedClassName = substr($error['message'], $prefixLen, -$notFoundSuffixLen);
-            if (false !== $namespaceSeparatorIndex = strrpos($fullyQualifiedClassName, '\\')) {
-                $className = substr($fullyQualifiedClassName, $namespaceSeparatorIndex + 1);
-                $namespacePrefix = substr($fullyQualifiedClassName, 0, $namespaceSeparatorIndex);
-                $message = sprintf('Attempted to load %s "%s" from namespace "%s".', $typeName, $className, $namespacePrefix);
-                $tail = ' for another namespace?';
+        if ($candidates = $this->getClassCandidates($className)) {
+            $tail = array_pop($candidates).'"?';
+            if ($candidates) {
+                $tail = ' for e.g. "'.implode('", "', $candidates).'" or "'.$tail;
             } else {
-                $className = $fullyQualifiedClassName;
-                $message = sprintf('Attempted to load %s "%s" from the global namespace.', $typeName, $className);
-                $tail = '?';
+                $tail = ' for "'.$tail;
             }
-
-            if ($candidates = $this->getClassCandidates($className)) {
-                $tail = array_pop($candidates).'"?';
-                if ($candidates) {
-                    $tail = ' for e.g. "'.implode('", "', $candidates).'" or "'.$tail;
-                } else {
-                    $tail = ' for "'.$tail;
-                }
-            }
-            $message .= "\nDid you forget a \"use\" statement".$tail;
-
-            return new ClassNotFoundException($message, $exception);
         }
+        $message .= "\nDid you forget a \"use\" statement".$tail;
 
-        return null;
+        return new ClassNotFoundException($message, $exception);
     }
 
     /**

Tests/ErrorHandlerTest.php

@@ -73,12 +73,12 @@ class ErrorHandlerTest extends TestCase
         $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
         $handler = ErrorHandler::register();
         $handler->setDefaultLogger($logger);
-        $handler->screamAt(E_ALL);
+        $handler->screamAt(\E_ALL);
 
         try {
-            @trigger_error('Hello', E_USER_WARNING);
+            @trigger_error('Hello', \E_USER_WARNING);
             $expected = [
-                'type' => E_USER_WARNING,
+                'type' => \E_USER_WARNING,
                 'message' => 'Hello',
                 'file' => __FILE__,
                 'line' => __LINE__ - 5,
@@ -102,10 +102,10 @@ class ErrorHandlerTest extends TestCase
         } catch (\ErrorException $exception) {
             // if an exception is thrown, the test passed
             if (\PHP_VERSION_ID < 80000) {
-                $this->assertEquals(E_NOTICE, $exception->getSeverity());
+                $this->assertEquals(\E_NOTICE, $exception->getSeverity());
                 $this->assertMatchesRegularExpression('/^Notice: Undefined variable: (foo|bar)/', $exception->getMessage());
             } else {
-                $this->assertEquals(E_WARNING, $exception->getSeverity());
+                $this->assertEquals(\E_WARNING, $exception->getSeverity());
                 $this->assertMatchesRegularExpression('/^Warning: Undefined variable \$(foo|bar)/', $exception->getMessage());
             }
             $this->assertEquals(__FILE__, $exception->getFile());
@@ -138,7 +138,7 @@ class ErrorHandlerTest extends TestCase
         try {
             $handler = ErrorHandler::register();
             $handler->throwAt(3, true);
-            $this->assertEquals(3 | E_RECOVERABLE_ERROR | E_USER_ERROR, $handler->throwAt(0));
+            $this->assertEquals(3 | \E_RECOVERABLE_ERROR | \E_USER_ERROR, $handler->throwAt(0));
         } finally {
             restore_error_handler();
             restore_exception_handler();
@@ -151,25 +151,25 @@ class ErrorHandlerTest extends TestCase
             $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
             $handler = ErrorHandler::register();
 
-            $handler->setDefaultLogger($logger, E_NOTICE);
-            $handler->setDefaultLogger($logger, [E_USER_NOTICE => LogLevel::CRITICAL]);
+            $handler->setDefaultLogger($logger, \E_NOTICE);
+            $handler->setDefaultLogger($logger, [\E_USER_NOTICE => LogLevel::CRITICAL]);
 
             $loggers = [
-                E_DEPRECATED => [null, LogLevel::INFO],
-                E_USER_DEPRECATED => [null, LogLevel::INFO],
-                E_NOTICE => [$logger, LogLevel::WARNING],
-                E_USER_NOTICE => [$logger, LogLevel::CRITICAL],
-                E_STRICT => [null, LogLevel::WARNING],
-                E_WARNING => [null, LogLevel::WARNING],
-                E_USER_WARNING => [null, LogLevel::WARNING],
-                E_COMPILE_WARNING => [null, LogLevel::WARNING],
-                E_CORE_WARNING => [null, LogLevel::WARNING],
-                E_USER_ERROR => [null, LogLevel::CRITICAL],
-                E_RECOVERABLE_ERROR => [null, LogLevel::CRITICAL],
-                E_COMPILE_ERROR => [null, LogLevel::CRITICAL],
-                E_PARSE => [null, LogLevel::CRITICAL],
-                E_ERROR => [null, LogLevel::CRITICAL],
-                E_CORE_ERROR => [null, LogLevel::CRITICAL],
+                \E_DEPRECATED => [null, LogLevel::INFO],
+                \E_USER_DEPRECATED => [null, LogLevel::INFO],
+                \E_NOTICE => [$logger, LogLevel::WARNING],
+                \E_USER_NOTICE => [$logger, LogLevel::CRITICAL],
+                \E_STRICT => [null, LogLevel::WARNING],
+                \E_WARNING => [null, LogLevel::WARNING],
+                \E_USER_WARNING => [null, LogLevel::WARNING],
+                \E_COMPILE_WARNING => [null, LogLevel::WARNING],
+                \E_CORE_WARNING => [null, LogLevel::WARNING],
+                \E_USER_ERROR => [null, LogLevel::CRITICAL],
+                \E_RECOVERABLE_ERROR => [null, LogLevel::CRITICAL],
+                \E_COMPILE_ERROR => [null, LogLevel::CRITICAL],
+                \E_PARSE => [null, LogLevel::CRITICAL],
+                \E_ERROR => [null, LogLevel::CRITICAL],
+                \E_CORE_ERROR => [null, LogLevel::CRITICAL],
             ];
             $this->assertSame($loggers, $handler->setLoggers([]));
         } finally {
@@ -210,15 +210,15 @@ class ErrorHandlerTest extends TestCase
             restore_exception_handler();
 
             $handler = ErrorHandler::register();
-            $handler->throwAt(E_USER_DEPRECATED, true);
-            $this->assertFalse($handler->handleError(E_USER_DEPRECATED, 'foo', 'foo.php', 12, []));
+            $handler->throwAt(\E_USER_DEPRECATED, true);
+            $this->assertFalse($handler->handleError(\E_USER_DEPRECATED, 'foo', 'foo.php', 12, []));
 
             restore_error_handler();
             restore_exception_handler();
 
             $handler = ErrorHandler::register();
-            $handler->throwAt(E_DEPRECATED, true);
-            $this->assertFalse($handler->handleError(E_DEPRECATED, 'foo', 'foo.php', 12, []));
+            $handler->throwAt(\E_DEPRECATED, true);
+            $this->assertFalse($handler->handleError(\E_DEPRECATED, 'foo', 'foo.php', 12, []));
 
             restore_error_handler();
             restore_exception_handler();
@@ -232,7 +232,7 @@ class ErrorHandlerTest extends TestCase
                 $exception = $context['exception'];
                 $this->assertInstanceOf(\ErrorException::class, $exception);
                 $this->assertSame('User Deprecated: foo', $exception->getMessage());
-                $this->assertSame(E_USER_DEPRECATED, $exception->getSeverity());
+                $this->assertSame(\E_USER_DEPRECATED, $exception->getSeverity());
             };
 
             $logger
@@ -242,8 +242,8 @@ class ErrorHandlerTest extends TestCase
             ;
 
             $handler = ErrorHandler::register();
-            $handler->setDefaultLogger($logger, E_USER_DEPRECATED);
-            $this->assertTrue($handler->handleError(E_USER_DEPRECATED, 'foo', 'foo.php', 12, []));
+            $handler->setDefaultLogger($logger, \E_USER_DEPRECATED);
+            $this->assertTrue($handler->handleError(\E_USER_DEPRECATED, 'foo', 'foo.php', 12, []));
 
             restore_error_handler();
             restore_exception_handler();
@@ -257,10 +257,10 @@ class ErrorHandlerTest extends TestCase
 
                 if (\PHP_VERSION_ID < 80000) {
                     $this->assertEquals('Notice: Undefined variable: undefVar', $message);
-                    $this->assertSame(E_NOTICE, $exception->getSeverity());
+                    $this->assertSame(\E_NOTICE, $exception->getSeverity());
                 } else {
                     $this->assertEquals('Warning: Undefined variable $undefVar', $message);
-                    $this->assertSame(E_WARNING, $exception->getSeverity());
+                    $this->assertSame(\E_WARNING, $exception->getSeverity());
                 }
                 $this->assertInstanceOf(SilencedErrorContext::class, $exception);
                 $this->assertSame(__FILE__, $exception->getFile());
@@ -277,11 +277,11 @@ class ErrorHandlerTest extends TestCase
 
             $handler = ErrorHandler::register();
             if (\PHP_VERSION_ID < 80000) {
-                $handler->setDefaultLogger($logger, E_NOTICE);
-                $handler->screamAt(E_NOTICE);
+                $handler->setDefaultLogger($logger, \E_NOTICE);
+                $handler->screamAt(\E_NOTICE);
             } else {
-                $handler->setDefaultLogger($logger, E_WARNING);
-                $handler->screamAt(E_WARNING);
+                $handler->setDefaultLogger($logger, \E_WARNING);
+                $handler->screamAt(\E_WARNING);
             }
             unset($undefVar);
             $line = __LINE__ + 1;
@@ -342,7 +342,7 @@ class ErrorHandlerTest extends TestCase
 
         $handler = new ErrorHandler();
         $handler->setDefaultLogger($logger);
-        @$handler->handleError(E_USER_DEPRECATED, 'Foo deprecation', __FILE__, __LINE__, []);
+        @$handler->handleError(\E_USER_DEPRECATED, 'Foo deprecation', __FILE__, __LINE__, []);
     }
 
     /**
@@ -368,7 +368,7 @@ class ErrorHandlerTest extends TestCase
                 ->willReturnCallback($logArgCheck)
             ;
 
-            $handler->setDefaultLogger($logger, E_ERROR);
+            $handler->setDefaultLogger($logger, \E_ERROR);
 
             try {
                 $handler->handleException($exception);
@@ -395,7 +395,7 @@ class ErrorHandlerTest extends TestCase
     {
         try {
             $handler = ErrorHandler::register();
-            $handler->screamAt(E_USER_WARNING);
+            $handler->screamAt(\E_USER_WARNING);
 
             $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
 
@@ -408,10 +408,10 @@ class ErrorHandlerTest extends TestCase
                 )
             ;
 
-            $handler->setDefaultLogger($logger, [E_USER_WARNING => LogLevel::WARNING]);
+            $handler->setDefaultLogger($logger, [\E_USER_WARNING => LogLevel::WARNING]);
 
             ErrorHandler::stackErrors();
-            @trigger_error('Silenced warning', E_USER_WARNING);
+            @trigger_error('Silenced warning', \E_USER_WARNING);
             $logger->log(LogLevel::WARNING, 'Dummy log');
             ErrorHandler::unstackErrors();
         } finally {
@@ -426,26 +426,26 @@ class ErrorHandlerTest extends TestCase
         $handler = new ErrorHandler($bootLogger);
 
         $loggers = [
-            E_DEPRECATED => [$bootLogger, LogLevel::INFO],
-            E_USER_DEPRECATED => [$bootLogger, LogLevel::INFO],
-            E_NOTICE => [$bootLogger, LogLevel::WARNING],
-            E_USER_NOTICE => [$bootLogger, LogLevel::WARNING],
-            E_STRICT => [$bootLogger, LogLevel::WARNING],
-            E_WARNING => [$bootLogger, LogLevel::WARNING],
-            E_USER_WARNING => [$bootLogger, LogLevel::WARNING],
-            E_COMPILE_WARNING => [$bootLogger, LogLevel::WARNING],
-            E_CORE_WARNING => [$bootLogger, LogLevel::WARNING],
-            E_USER_ERROR => [$bootLogger, LogLevel::CRITICAL],
-            E_RECOVERABLE_ERROR => [$bootLogger, LogLevel::CRITICAL],
-            E_COMPILE_ERROR => [$bootLogger, LogLevel::CRITICAL],
-            E_PARSE => [$bootLogger, LogLevel::CRITICAL],
-            E_ERROR => [$bootLogger, LogLevel::CRITICAL],
-            E_CORE_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_DEPRECATED => [$bootLogger, LogLevel::INFO],
+            \E_USER_DEPRECATED => [$bootLogger, LogLevel::INFO],
+            \E_NOTICE => [$bootLogger, LogLevel::WARNING],
+            \E_USER_NOTICE => [$bootLogger, LogLevel::WARNING],
+            \E_STRICT => [$bootLogger, LogLevel::WARNING],
+            \E_WARNING => [$bootLogger, LogLevel::WARNING],
+            \E_USER_WARNING => [$bootLogger, LogLevel::WARNING],
+            \E_COMPILE_WARNING => [$bootLogger, LogLevel::WARNING],
+            \E_CORE_WARNING => [$bootLogger, LogLevel::WARNING],
+            \E_USER_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_RECOVERABLE_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_COMPILE_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_PARSE => [$bootLogger, LogLevel::CRITICAL],
+            \E_ERROR => [$bootLogger, LogLevel::CRITICAL],
+            \E_CORE_ERROR => [$bootLogger, LogLevel::CRITICAL],
         ];
 
         $this->assertSame($loggers, $handler->setLoggers([]));
 
-        $handler->handleError(E_DEPRECATED, 'Foo message', __FILE__, 123, []);
+        $handler->handleError(\E_DEPRECATED, 'Foo message', __FILE__, 123, []);
 
         $logs = $bootLogger->cleanLogs();
 
@@ -459,7 +459,7 @@ class ErrorHandlerTest extends TestCase
         $this->assertSame('Deprecated: Foo message', $exception->getMessage());
         $this->assertSame(__FILE__, $exception->getFile());
         $this->assertSame(123, $exception->getLine());
-        $this->assertSame(E_DEPRECATED, $exception->getSeverity());
+        $this->assertSame(\E_DEPRECATED, $exception->getSeverity());
 
         $bootLogger->log(LogLevel::WARNING, 'Foo message', ['exception' => $exception]);
 
@@ -468,7 +468,7 @@ class ErrorHandlerTest extends TestCase
             ->method('log')
             ->with(LogLevel::WARNING, 'Foo message', ['exception' => $exception]);
 
-        $handler->setLoggers([E_DEPRECATED => [$mockLogger, LogLevel::WARNING]]);
+        $handler->setLoggers([\E_DEPRECATED => [$mockLogger, LogLevel::WARNING]]);
     }
 
     /**
@@ -503,7 +503,7 @@ class ErrorHandlerTest extends TestCase
             $handler = ErrorHandler::register();
 
             $error = [
-                'type' => E_PARSE,
+                'type' => \E_PARSE,
                 'message' => 'foo',
                 'file' => 'bar',
                 'line' => 123,
@@ -521,7 +521,7 @@ class ErrorHandlerTest extends TestCase
                 ->willReturnCallback($logArgCheck)
             ;
 
-            $handler->setDefaultLogger($logger, E_PARSE);
+            $handler->setDefaultLogger($logger, \E_PARSE);
 
             $handler->handleFatalError($error);
 
@@ -558,6 +558,10 @@ class ErrorHandlerTest extends TestCase
      */
     public function testHandleFatalErrorOnHHVM()
     {
+        if (!\defined('HHVM_VERSION')) {
+            $this->markTestSkipped('This test requires HHVM.');
+        }
+
         try {
             $handler = ErrorHandler::register();
 
@@ -571,10 +575,10 @@ class ErrorHandlerTest extends TestCase
                 )
             ;
 
-            $handler->setDefaultLogger($logger, E_ERROR);
+            $handler->setDefaultLogger($logger, \E_ERROR);
 
             $error = [
-                'type' => E_ERROR + 0x1000000, // This error level is used by HHVM for fatal errors
+                'type' => \E_ERROR + 0x1000000, // This error level is used by HHVM for fatal errors
                 'message' => 'foo',
                 'file' => 'bar',
                 'line' => 123,
@@ -623,8 +627,8 @@ class ErrorHandlerTest extends TestCase
                 $handler = ErrorHandlerThatUsesThePreviousOne::register();
             }
 
-            @trigger_error('foo', E_USER_DEPRECATED);
-            @trigger_error('bar', E_USER_DEPRECATED);
+            @trigger_error('foo', \E_USER_DEPRECATED);
+            @trigger_error('bar', \E_USER_DEPRECATED);
 
             $this->assertSame([$handler, 'handleError'], set_error_handler('var_dump'));
 

Tests/Exception/FlattenExceptionTest.php

@@ -224,8 +224,8 @@ class FlattenExceptionTest extends TestCase
             0.0,
             '0',
             '',
-            INF,
-            NAN,
+            \INF,
+            \NAN,
         ]);
 
         $flattened = FlattenException::create($exception);
@@ -256,7 +256,7 @@ class FlattenExceptionTest extends TestCase
         $this->assertSame(['float', 0.0], $array[$i++]);
         $this->assertSame(['string', '0'], $array[$i++]);
         $this->assertSame(['string', ''], $array[$i++]);
-        $this->assertSame(['float', INF], $array[$i++]);
+        $this->assertSame(['float', \INF], $array[$i++]);
 
         // assertEquals() does not like NAN values.
         $this->assertEquals('float', $array[$i][0]);

Tests/ExceptionHandlerTest.php

@@ -150,7 +150,7 @@ class ExceptionHandlerTest extends TestCase
             $this->fail('OutOfMemoryException should bypass the handler');
         });
 
-        $handler->handle(new OutOfMemoryException('foo', 0, E_ERROR, __FILE__, __LINE__));
+        $handler->handle(new OutOfMemoryException('foo', 0, \E_ERROR, __FILE__, __LINE__));
 
         $this->assertThatTheExceptionWasOutput(ob_get_clean(), OutOfMemoryException::class, 'OutOfMemoryException', 'foo');
     }

Tests/FatalErrorHandler/ClassNotFoundFatalErrorHandlerTest.php

@@ -80,6 +80,15 @@ class ClassNotFoundFatalErrorHandlerTest extends TestCase
         $debugClassLoader = new DebugClassLoader([$autoloader, 'loadClass']);
 
         return [
+            [
+                [
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class "WhizBangFactory" not found',
+                ],
+                "/^Attempted to load class \"WhizBangFactory\" from the global namespace.\nDid you forget a \"use\" statement\?$/",
+            ],
             [
                 [
                     'type' => 1,
@@ -98,6 +107,33 @@ class ClassNotFoundFatalErrorHandlerTest extends TestCase
                 ],
                 "/^Attempted to load class \"WhizBangFactory\" from namespace \"Foo\\\\Bar\".\nDid you forget a \"use\" statement for another namespace\?$/",
             ],
+            [
+                [
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class "Foo\\Bar\\WhizBangFactory" not found',
+                ],
+                "/^Attempted to load class \"WhizBangFactory\" from namespace \"Foo\\\\Bar\".\nDid you forget a \"use\" statement for another namespace\?$/",
+            ],
+            [
+                [
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Interface "Foo\\Bar\\WhizBangInterface" not found',
+                ],
+                "/^Attempted to load interface \"WhizBangInterface\" from namespace \"Foo\\\\Bar\".\nDid you forget a \"use\" statement for another namespace\?$/",
+            ],
+            [
+                [
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Trait "Foo\\Bar\\WhizBangTrait" not found',
+                ],
+                "/^Attempted to load trait \"WhizBangTrait\" from namespace \"Foo\\\\Bar\".\nDid you forget a \"use\" statement for another namespace\?$/",
+            ],
             [
                 [
                     'type' => 1,