Merge branch '2.8' into 3.4

nicolas-grekas · nicolas-grekas · commit dc88ebbe853c · 2018-07-26T10:45:46.000+02:00
* 2.8:
  Fix Clidumper tests
  Enable the fixer enforcing fully-qualified calls for compiler-optimized functions
  Apply fixers
  Disable the native_constant_invocation fixer until it can be scoped
  Update the list of excluded files for the CS fixer
diff --git a/ClockMock.php b/ClockMock.php
@@ -71,7 +71,7 @@ public static function microtime($asFloat = false)
 
     public static function register($class)
     {
-        $self = get_called_class();
+        $self = \get_called_class();
 
         $mockedNs = array(substr($class, 0, strrpos($class, '\\')));
         if (0 < strpos($class, '\\Tests\\')) {
@@ -81,7 +81,7 @@ public static function register($class)
             $mockedNs[] = substr($class, 6, strrpos($class, '\\') - 6);
         }
         foreach ($mockedNs as $ns) {
-            if (function_exists($ns.'\time')) {
+            if (\function_exists($ns.'\time')) {
                 continue;
             }
             eval(<<<EOPHP
diff --git a/DeprecationErrorHandler.php b/DeprecationErrorHandler.php
@@ -68,7 +68,7 @@ public static function register($mode = 0)
                 foreach (get_declared_classes() as $class) {
                     if ('C' === $class[0] && 0 === strpos($class, 'ComposerAutoloaderInit')) {
                         $r = new \ReflectionClass($class);
-                        $v = dirname(dirname($r->getFileName()));
+                        $v = \dirname(\dirname($r->getFileName()));
                         if (file_exists($v.'/composer/installed.json')) {
                             $vendors[] = $v;
                         }
@@ -80,7 +80,7 @@ public static function register($mode = 0)
                 return true;
             }
             foreach ($vendors as $vendor) {
-                if (0 === strpos($realPath, $vendor) && false !== strpbrk(substr($realPath, strlen($vendor), 1), '/'.DIRECTORY_SEPARATOR)) {
+                if (0 === strpos($realPath, $vendor) && false !== strpbrk(substr($realPath, \strlen($vendor), 1), '/'.DIRECTORY_SEPARATOR)) {
                     return true;
                 }
             }
@@ -112,7 +112,7 @@ public static function register($mode = 0)
             $group = 'other';
             $isVendor = DeprecationErrorHandler::MODE_WEAK_VENDORS === $mode && $inVendors($file);
 
-            $i = count($trace);
+            $i = \count($trace);
             while (1 < $i && (!isset($trace[--$i]['class']) || ('ReflectionMethod' === $trace[$i]['class'] || 0 === strpos($trace[$i]['class'], 'PHPUnit_') || 0 === strpos($trace[$i]['class'], 'PHPUnit\\')))) {
                 // No-op
             }
@@ -129,7 +129,7 @@ public static function register($mode = 0)
                     // if the error has been triggered from vendor code.
                     $isVendor = DeprecationErrorHandler::MODE_WEAK_VENDORS === $mode && isset($parsedMsg['triggering_file']) && $inVendors($parsedMsg['triggering_file']);
                 } else {
-                    $class = isset($trace[$i]['object']) ? get_class($trace[$i]['object']) : $trace[$i]['class'];
+                    $class = isset($trace[$i]['object']) ? \get_class($trace[$i]['object']) : $trace[$i]['class'];
                     $method = $trace[$i]['function'];
                 }
 
@@ -141,7 +141,7 @@ public static function register($mode = 0)
                     || 0 === strpos($method, 'provideLegacy')
                     || 0 === strpos($method, 'getLegacy')
                     || strpos($class, '\Legacy')
-                    || in_array('legacy', $Test::getGroups($class, $method), true)
+                    || \in_array('legacy', $Test::getGroups($class, $method), true)
                 ) {
                     $group = 'legacy';
                 } elseif ($isVendor) {
@@ -154,7 +154,7 @@ public static function register($mode = 0)
                     $e = new \Exception($msg);
                     $r = new \ReflectionProperty($e, 'trace');
                     $r->setAccessible(true);
-                    $r->setValue($e, array_slice($trace, 1, $i));
+                    $r->setValue($e, \array_slice($trace, 1, $i));
 
                     echo "\n".ucfirst($group).' deprecation triggered by '.$class.'::'.$method.':';
                     echo "\n".$msg;
@@ -255,12 +255,12 @@ public static function register($mode = 0)
 
                 // reset deprecations array
                 foreach ($deprecations as $group => $arrayOrInt) {
-                    $deprecations[$group] = is_int($arrayOrInt) ? 0 : array();
+                    $deprecations[$group] = \is_int($arrayOrInt) ? 0 : array();
                 }
 
                 register_shutdown_function(function () use (&$deprecations, $isFailing, $displayDeprecations, $mode) {
                     foreach ($deprecations as $group => $arrayOrInt) {
-                        if (0 < (is_int($arrayOrInt) ? $arrayOrInt : count($arrayOrInt))) {
+                        if (0 < (\is_int($arrayOrInt) ? $arrayOrInt : \count($arrayOrInt))) {
                             echo "Shutdown-time deprecations:\n";
                             break;
                         }
@@ -307,7 +307,7 @@ public static function collectDeprecations($outputFile)
      */
     private static function hasColorSupport()
     {
-        if (!defined('STDOUT')) {
+        if (!\defined('STDOUT')) {
             return false;
         }
 
@@ -316,18 +316,18 @@ private static function hasColorSupport()
         }
 
         if (DIRECTORY_SEPARATOR === '\\') {
-            return (function_exists('sapi_windows_vt100_support')
+            return (\function_exists('sapi_windows_vt100_support')
                 && sapi_windows_vt100_support(STDOUT))
                 || false !== getenv('ANSICON')
                 || 'ON' === getenv('ConEmuANSI')
                 || 'xterm' === getenv('TERM');
         }
 
-        if (function_exists('stream_isatty')) {
+        if (\function_exists('stream_isatty')) {
             return stream_isatty(STDOUT);
         }
 
-        if (function_exists('posix_isatty')) {
+        if (\function_exists('posix_isatty')) {
             return posix_isatty(STDOUT);
         }
 
diff --git a/DnsMock.php b/DnsMock.php
@@ -163,7 +163,7 @@ public static function dns_get_record($hostname, $type = DNS_ANY, &$authns = nul
 
     public static function register($class)
     {
-        $self = get_called_class();
+        $self = \get_called_class();
 
         $mockedNs = array(substr($class, 0, strrpos($class, '\\')));
         if (0 < strpos($class, '\\Tests\\')) {
@@ -173,7 +173,7 @@ public static function register($class)
             $mockedNs[] = substr($class, 6, strrpos($class, '\\') - 6);
         }
         foreach ($mockedNs as $ns) {
-            if (function_exists($ns.'\checkdnsrr')) {
+            if (\function_exists($ns.'\checkdnsrr')) {
                 continue;
             }
             eval(<<<EOPHP
diff --git a/Legacy/CoverageListenerTrait.php b/Legacy/CoverageListenerTrait.php
@@ -58,7 +58,7 @@ public function startTest($test)
                 if (method_exists($test->getTestResultObject(), 'addWarning') && class_exists(Warning::class)) {
                     $test->getTestResultObject()->addWarning($test, new Warning($message), 0);
                 } else {
-                    $this->warnings[] = sprintf("%s::%s\n%s", get_class($test), $test->getName(), $message);
+                    $this->warnings[] = sprintf("%s::%s\n%s", \get_class($test), $test->getName(), $message);
                 }
             }
 
@@ -75,7 +75,7 @@ public function startTest($test)
 
         $cache = $r->getValue();
         $cache = array_replace_recursive($cache, array(
-            get_class($test) => array(
+            \get_class($test) => array(
                 'covers' => array($sutFqcn),
             ),
         ));
@@ -90,7 +90,7 @@ private function findSutFqcn($test)
             return $resolver($test);
         }
 
-        $class = get_class($test);
+        $class = \get_class($test);
 
         $sutFqcn = str_replace('\\Tests\\', '\\', $class);
         $sutFqcn = preg_replace('{Test$}', '', $sutFqcn);
diff --git a/Legacy/SymfonyTestsListenerTrait.php b/Legacy/SymfonyTestsListenerTrait.php
@@ -54,10 +54,10 @@ public function __construct(array $mockedNamespaces = array())
 
         $warn = false;
         foreach ($mockedNamespaces as $type => $namespaces) {
-            if (!is_array($namespaces)) {
+            if (!\is_array($namespaces)) {
                 $namespaces = array($namespaces);
             }
-            if (is_int($type)) {
+            if (\is_int($type)) {
                 // @deprecated BC with v2.8 to v3.0
                 $type = 'time-sensitive';
                 $warn = true;
@@ -107,10 +107,10 @@ public function startTestSuite($suite)
         $this->testsWithWarnings = array();
 
         foreach ($suite->tests() as $test) {
-            if (!($test instanceof \PHPUnit_Framework_TestCase || $test instanceof TestCase)) {
+            if (!($test instanceof \PHPUnit\Framework\TestCase || $test instanceof TestCase)) {
                 continue;
             }
-            if (null === $Test::getPreserveGlobalStateSettings(get_class($test), $test->getName(false))) {
+            if (null === $Test::getPreserveGlobalStateSettings(\get_class($test), $test->getName(false))) {
                 $test->setPreserveGlobalState(false);
             }
         }
@@ -148,10 +148,10 @@ public function startTestSuite($suite)
                             continue;
                         }
                         $groups = $Test::getGroups($test->getName());
-                        if (in_array('time-sensitive', $groups, true)) {
+                        if (\in_array('time-sensitive', $groups, true)) {
                             ClockMock::register($test->getName());
                         }
-                        if (in_array('dns-sensitive', $groups, true)) {
+                        if (\in_array('dns-sensitive', $groups, true)) {
                             DnsMock::register($test->getName());
                         }
                     }
@@ -160,7 +160,7 @@ public function startTestSuite($suite)
         } elseif (2 === $this->state) {
             $skipped = array();
             foreach ($suite->tests() as $test) {
-                if (!($test instanceof \PHPUnit_Framework_TestCase || $test instanceof TestCase)
+                if (!($test instanceof \PHPUnit\Framework\TestCase || $test instanceof TestCase)
                     || isset($this->wasSkipped[$suiteName]['*'])
                     || isset($this->wasSkipped[$suiteName][$test->getName()])) {
                     $skipped[] = $test;
@@ -173,8 +173,8 @@ public function startTestSuite($suite)
     public function addSkippedTest($test, \Exception $e, $time)
     {
         if (0 < $this->state) {
-            if ($test instanceof \PHPUnit_Framework_TestCase || $test instanceof TestCase) {
-                $class = get_class($test);
+            if ($test instanceof \PHPUnit\Framework\TestCase || $test instanceof TestCase) {
+                $class = \get_class($test);
                 $method = $test->getName();
             } else {
                 $class = $test->getName();
@@ -187,7 +187,7 @@ public function addSkippedTest($test, \Exception $e, $time)
 
     public function startTest($test)
     {
-        if (-2 < $this->state && ($test instanceof \PHPUnit_Framework_TestCase || $test instanceof TestCase)) {
+        if (-2 < $this->state && ($test instanceof \PHPUnit\Framework\TestCase || $test instanceof TestCase)) {
             if (null !== $test->getTestResultObject()) {
                 $this->reportUselessTests = $test->getTestResultObject()->isStrictAboutTestsThatDoNotTestAnything();
             }
@@ -205,25 +205,25 @@ public function startTest($test)
                 $Test = 'PHPUnit\Util\Test';
                 $AssertionFailedError = 'PHPUnit\Framework\AssertionFailedError';
             }
-            $groups = $Test::getGroups(get_class($test), $test->getName(false));
+            $groups = $Test::getGroups(\get_class($test), $test->getName(false));
 
             if (!$this->runsInSeparateProcess) {
-                if (in_array('time-sensitive', $groups, true)) {
-                    ClockMock::register(get_class($test));
+                if (\in_array('time-sensitive', $groups, true)) {
+                    ClockMock::register(\get_class($test));
                     ClockMock::withClockMock(true);
                 }
-                if (in_array('dns-sensitive', $groups, true)) {
-                    DnsMock::register(get_class($test));
+                if (\in_array('dns-sensitive', $groups, true)) {
+                    DnsMock::register(\get_class($test));
                 }
             }
 
-            $annotations = $Test::parseTestMethodAnnotations(get_class($test), $test->getName(false));
+            $annotations = $Test::parseTestMethodAnnotations(\get_class($test), $test->getName(false));
 
             if (isset($annotations['class']['expectedDeprecation'])) {
                 $test->getTestResultObject()->addError($test, new $AssertionFailedError('`@expectedDeprecation` annotations are not allowed at the class level.'), 0);
             }
             if (isset($annotations['method']['expectedDeprecation'])) {
-                if (!in_array('legacy', $groups, true)) {
+                if (!\in_array('legacy', $groups, true)) {
                     $this->error = new $AssertionFailedError('Only tests with the `@group legacy` annotation can have `@expectedDeprecation`.');
                 }
 
@@ -237,7 +237,7 @@ public function startTest($test)
 
     public function addWarning($test, $e, $time)
     {
-        if ($test instanceof \PHPUnit_Framework_TestCase || $test instanceof TestCase) {
+        if ($test instanceof \PHPUnit\Framework\TestCase || $test instanceof TestCase) {
             $this->testsWithWarnings[$test->getName()] = true;
         }
     }
@@ -253,7 +253,7 @@ public function endTest($test, $time)
             $BaseTestRunner = 'PHPUnit\Runner\BaseTestRunner';
             $Warning = 'PHPUnit\Framework\Warning';
         }
-        $className = get_class($test);
+        $className = \get_class($test);
         $classGroups = $Test::getGroups($className);
         $groups = $Test::getGroups($className, $test->getName(false));
 
@@ -274,7 +274,7 @@ public function endTest($test, $time)
             foreach ($deprecations ? unserialize($deprecations) : array() as $deprecation) {
                 $error = serialize(array('deprecation' => $deprecation[1], 'class' => $className, 'method' => $test->getName(false), 'triggering_file' => isset($deprecation[2]) ? $deprecation[2] : null));
                 if ($deprecation[0]) {
-                    trigger_error($error, E_USER_DEPRECATED);
+                    @trigger_error($error, E_USER_DEPRECATED);
                 } else {
                     @trigger_error($error, E_USER_DEPRECATED);
                 }
@@ -283,13 +283,13 @@ public function endTest($test, $time)
         }
 
         if ($this->expectedDeprecations) {
-            if (!in_array($test->getStatus(), array($BaseTestRunner::STATUS_SKIPPED, $BaseTestRunner::STATUS_INCOMPLETE), true)) {
-                $test->addToAssertionCount(count($this->expectedDeprecations));
+            if (!\in_array($test->getStatus(), array($BaseTestRunner::STATUS_SKIPPED, $BaseTestRunner::STATUS_INCOMPLETE), true)) {
+                $test->addToAssertionCount(\count($this->expectedDeprecations));
             }
 
             restore_error_handler();
 
-            if (!$errored && !in_array($test->getStatus(), array($BaseTestRunner::STATUS_SKIPPED, $BaseTestRunner::STATUS_INCOMPLETE, $BaseTestRunner::STATUS_FAILURE, $BaseTestRunner::STATUS_ERROR), true)) {
+            if (!$errored && !\in_array($test->getStatus(), array($BaseTestRunner::STATUS_SKIPPED, $BaseTestRunner::STATUS_INCOMPLETE, $BaseTestRunner::STATUS_FAILURE, $BaseTestRunner::STATUS_ERROR), true)) {
                 try {
                     $prefix = "@expectedDeprecation:\n";
                     $test->assertStringMatchesFormat($prefix.'%A  '.implode("\n%A  ", $this->expectedDeprecations)."\n%A", $prefix.'  '.implode("\n  ", $this->gatheredDeprecations)."\n");
@@ -303,24 +303,24 @@ public function endTest($test, $time)
             $this->expectedDeprecations = $this->gatheredDeprecations = array();
             $this->previousErrorHandler = null;
         }
-        if (!$this->runsInSeparateProcess && -2 < $this->state && ($test instanceof \PHPUnit_Framework_TestCase || $test instanceof TestCase)) {
-            if (in_array('time-sensitive', $groups, true)) {
+        if (!$this->runsInSeparateProcess && -2 < $this->state && ($test instanceof \PHPUnit\Framework\TestCase || $test instanceof TestCase)) {
+            if (\in_array('time-sensitive', $groups, true)) {
                 ClockMock::withClockMock(false);
             }
-            if (in_array('dns-sensitive', $groups, true)) {
+            if (\in_array('dns-sensitive', $groups, true)) {
                 DnsMock::withMockedHosts(array());
             }
         }
 
-        if (($test instanceof \PHPUnit_Framework_TestCase || $test instanceof TestCase) && 0 === strpos($test->getName(), 'testLegacy') && !isset($this->testsWithWarnings[$test->getName()]) && !in_array('legacy', $groups, true)) {
+        if (($test instanceof \PHPUnit\Framework\TestCase || $test instanceof TestCase) && 0 === strpos($test->getName(), 'testLegacy') && !isset($this->testsWithWarnings[$test->getName()]) && !\in_array('legacy', $groups, true)) {
             $result = $test->getTestResultObject();
 
             if (method_exists($result, 'addWarning')) {
                 $result->addWarning($test, new $Warning('Using the "testLegacy" prefix to mark tests as legacy is deprecated since version 3.3 and will be removed in 4.0. Use the "@group legacy" notation instead to add the test to the legacy group.'), $time);
             }
         }
 
-        if (($test instanceof \PHPUnit_Framework_TestCase || $test instanceof TestCase) && strpos($className, '\Legacy') && !isset($this->testsWithWarnings[$test->getName()]) && !in_array('legacy', $classGroups, true)) {
+        if (($test instanceof \PHPUnit\Framework\TestCase || $test instanceof TestCase) && strpos($className, '\Legacy') && !isset($this->testsWithWarnings[$test->getName()]) && !\in_array('legacy', $classGroups, true)) {
             $result = $test->getTestResultObject();
 
             if (method_exists($result, 'addWarning')) {
@@ -339,7 +339,7 @@ public function handleError($type, $msg, $file, $line, $context = array())
         // If the message is serialized we need to extract the message. This occurs when the error is triggered by
         // by the isolated test path in \Symfony\Bridge\PhpUnit\Legacy\SymfonyTestsListenerTrait::endTest().
         $parsedMsg = @unserialize($msg);
-        if (is_array($parsedMsg)) {
+        if (\is_array($parsedMsg)) {
             $msg = $parsedMsg['deprecation'];
         }
         if (error_reporting()) {
diff --git a/Tests/CoverageListenerTest.php b/Tests/CoverageListenerTest.php
@@ -12,7 +12,7 @@ public function test()
             $this->markTestSkipped('This test cannot be run on Windows.');
         }
 
-        if (defined('HHVM_VERSION')) {
+        if (\defined('HHVM_VERSION')) {
             $this->markTestSkipped('This test cannot be run on HHVM.');
         }
 

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ public static function microtime($asFloat = false)`
`71`	`71`
`72`	`72`	`public static function register($class)`
`73`	`73`	`{`
`74`		`- $self = get_called_class();`
	`74`	`+ $self = \get_called_class();`
`75`	`75`
`76`	`76`	`$mockedNs = array(substr($class, 0, strrpos($class, '\\')));`
`77`	`77`	`if (0 < strpos($class, '\\Tests\\')) {`
`@@ -81,7 +81,7 @@ public static function register($class)`
`81`	`81`	`$mockedNs[] = substr($class, 6, strrpos($class, '\\') - 6);`
`82`	`82`	`}`
`83`	`83`	`foreach ($mockedNs as $ns) {`
`84`		`- if (function_exists($ns.'\time')) {`
	`84`	`+ if (\function_exists($ns.'\time')) {`
`85`	`85`	`continue;`
`86`	`86`	`}`
`87`	`87`	`eval(<<<EOPHP`
Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ public static function dns_get_record($hostname, $type = DNS_ANY, &$authns = nul`
`163`	`163`
`164`	`164`	`public static function register($class)`
`165`	`165`	`{`
`166`		`- $self = get_called_class();`
	`166`	`+ $self = \get_called_class();`
`167`	`167`
`168`	`168`	`$mockedNs = array(substr($class, 0, strrpos($class, '\\')));`
`169`	`169`	`if (0 < strpos($class, '\\Tests\\')) {`
`@@ -173,7 +173,7 @@ public static function register($class)`
`173`	`173`	`$mockedNs[] = substr($class, 6, strrpos($class, '\\') - 6);`
`174`	`174`	`}`
`175`	`175`	`foreach ($mockedNs as $ns) {`
`176`		`- if (function_exists($ns.'\checkdnsrr')) {`
	`176`	`+ if (\function_exists($ns.'\checkdnsrr')) {`
`177`	`177`	`continue;`
`178`	`178`	`}`
`179`	`179`	`eval(<<<EOPHP`
Original file line number	Diff line number	Diff line change
`@@ -54,10 +54,10 @@ public function __construct(array $mockedNamespaces = array())`
`54`	`54`
`55`	`55`	`$warn = false;`
`56`	`56`	`foreach ($mockedNamespaces as $type => $namespaces) {`
`57`		`- if (!is_array($namespaces)) {`
	`57`	`+ if (!\is_array($namespaces)) {`
`58`	`58`	`$namespaces = array($namespaces);`
`59`	`59`	`}`
`60`		`- if (is_int($type)) {`
	`60`	`+ if (\is_int($type)) {`
`61`	`61`	`// @deprecated BC with v2.8 to v3.0`
`62`	`62`	`$type = 'time-sensitive';`
`63`	`63`	`$warn = true;`
`@@ -107,10 +107,10 @@ public function startTestSuite($suite)`
`107`	`107`	`$this->testsWithWarnings = array();`
`108`	`108`
`109`	`109`	`foreach ($suite->tests() as $test) {`
`110`		`- if (!($test instanceof \PHPUnit_Framework_TestCase \|\| $test instanceof TestCase)) {`
	`110`	`+ if (!($test instanceof \PHPUnit\Framework\TestCase \|\| $test instanceof TestCase)) {`
`111`	`111`	`continue;`
`112`	`112`	`}`
`113`		`- if (null === $Test::getPreserveGlobalStateSettings(get_class($test), $test->getName(false))) {`
	`113`	`+ if (null === $Test::getPreserveGlobalStateSettings(\get_class($test), $test->getName(false))) {`
`114`	`114`	`$test->setPreserveGlobalState(false);`
`115`	`115`	`}`
`116`	`116`	`}`
`@@ -148,10 +148,10 @@ public function startTestSuite($suite)`
`148`	`148`	`continue;`
`149`	`149`	`}`
`150`	`150`	`$groups = $Test::getGroups($test->getName());`
`151`		`- if (in_array('time-sensitive', $groups, true)) {`
	`151`	`+ if (\in_array('time-sensitive', $groups, true)) {`
`152`	`152`	`ClockMock::register($test->getName());`
`153`	`153`	`}`
`154`		`- if (in_array('dns-sensitive', $groups, true)) {`
	`154`	`+ if (\in_array('dns-sensitive', $groups, true)) {`
`155`	`155`	`DnsMock::register($test->getName());`
`156`	`156`	`}`
`157`	`157`	`}`
`@@ -160,7 +160,7 @@ public function startTestSuite($suite)`
`160`	`160`	`} elseif (2 === $this->state) {`
`161`	`161`	`$skipped = array();`
`162`	`162`	`foreach ($suite->tests() as $test) {`
`163`		`- if (!($test instanceof \PHPUnit_Framework_TestCase \|\| $test instanceof TestCase)`
	`163`	`+ if (!($test instanceof \PHPUnit\Framework\TestCase \|\| $test instanceof TestCase)`
`164`	`164`	`\|\| isset($this->wasSkipped[$suiteName]['*'])`
`165`	`165`	`\|\| isset($this->wasSkipped[$suiteName][$test->getName()])) {`
`166`	`166`	`$skipped[] = $test;`
`@@ -173,8 +173,8 @@ public function startTestSuite($suite)`
`173`	`173`	`public function addSkippedTest($test, \Exception $e, $time)`
`174`	`174`	`{`
`175`	`175`	`if (0 < $this->state) {`
`176`		`- if ($test instanceof \PHPUnit_Framework_TestCase \|\| $test instanceof TestCase) {`
`177`		`- $class = get_class($test);`
	`176`	`+ if ($test instanceof \PHPUnit\Framework\TestCase \|\| $test instanceof TestCase) {`
	`177`	`+ $class = \get_class($test);`
`178`	`178`	`$method = $test->getName();`
`179`	`179`	`} else {`
`180`	`180`	`$class = $test->getName();`
`@@ -187,7 +187,7 @@ public function addSkippedTest($test, \Exception $e, $time)`
`187`	`187`
`188`	`188`	`public function startTest($test)`
`189`	`189`	`{`
`190`		`- if (-2 < $this->state && ($test instanceof \PHPUnit_Framework_TestCase \|\| $test instanceof TestCase)) {`
	`190`	`+ if (-2 < $this->state && ($test instanceof \PHPUnit\Framework\TestCase \|\| $test instanceof TestCase)) {`
`191`	`191`	`if (null !== $test->getTestResultObject()) {`
`192`	`192`	`$this->reportUselessTests = $test->getTestResultObject()->isStrictAboutTestsThatDoNotTestAnything();`
`193`	`193`	`}`
`@@ -205,25 +205,25 @@ public function startTest($test)`
`205`	`205`	`$Test = 'PHPUnit\Util\Test';`
`206`	`206`	`$AssertionFailedError = 'PHPUnit\Framework\AssertionFailedError';`
`207`	`207`	`}`
`208`		`- $groups = $Test::getGroups(get_class($test), $test->getName(false));`
	`208`	`+ $groups = $Test::getGroups(\get_class($test), $test->getName(false));`
`209`	`209`
`210`	`210`	`if (!$this->runsInSeparateProcess) {`
`211`		`- if (in_array('time-sensitive', $groups, true)) {`
`212`		`- ClockMock::register(get_class($test));`
	`211`	`+ if (\in_array('time-sensitive', $groups, true)) {`
	`212`	`+ ClockMock::register(\get_class($test));`
`213`	`213`	`ClockMock::withClockMock(true);`
`214`	`214`	`}`
`215`		`- if (in_array('dns-sensitive', $groups, true)) {`
`216`		`- DnsMock::register(get_class($test));`
	`215`	`+ if (\in_array('dns-sensitive', $groups, true)) {`
	`216`	`+ DnsMock::register(\get_class($test));`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`
`220`		`- $annotations = $Test::parseTestMethodAnnotations(get_class($test), $test->getName(false));`
	`220`	`+ $annotations = $Test::parseTestMethodAnnotations(\get_class($test), $test->getName(false));`
`221`	`221`
`222`	`222`	`if (isset($annotations['class']['expectedDeprecation'])) {`
`223`	`223`	$test->getTestResultObject()->addError($test, new $AssertionFailedError('`@expectedDeprecation` annotations are not allowed at the class level.'), 0);
`224`	`224`	`}`
`225`	`225`	`if (isset($annotations['method']['expectedDeprecation'])) {`
`226`		`- if (!in_array('legacy', $groups, true)) {`
	`226`	`+ if (!\in_array('legacy', $groups, true)) {`
`227`	`227`	$this->error = new $AssertionFailedError('Only tests with the `@group legacy` annotation can have `@expectedDeprecation`.');
`228`	`228`	`}`
`229`	`229`
`@@ -237,7 +237,7 @@ public function startTest($test)`
`237`	`237`
`238`	`238`	`public function addWarning($test, $e, $time)`
`239`	`239`	`{`
`240`		`- if ($test instanceof \PHPUnit_Framework_TestCase \|\| $test instanceof TestCase) {`
	`240`	`+ if ($test instanceof \PHPUnit\Framework\TestCase \|\| $test instanceof TestCase) {`
`241`	`241`	`$this->testsWithWarnings[$test->getName()] = true;`
`242`	`242`	`}`
`243`	`243`	`}`
`@@ -253,7 +253,7 @@ public function endTest($test, $time)`
`253`	`253`	`$BaseTestRunner = 'PHPUnit\Runner\BaseTestRunner';`
`254`	`254`	`$Warning = 'PHPUnit\Framework\Warning';`
`255`	`255`	`}`
`256`		`- $className = get_class($test);`
	`256`	`+ $className = \get_class($test);`
`257`	`257`	`$classGroups = $Test::getGroups($className);`
`258`	`258`	`$groups = $Test::getGroups($className, $test->getName(false));`
`259`	`259`
`@@ -274,7 +274,7 @@ public function endTest($test, $time)`
`274`	`274`	`foreach ($deprecations ? unserialize($deprecations) : array() as $deprecation) {`
`275`	`275`	`$error = serialize(array('deprecation' => $deprecation[1], 'class' => $className, 'method' => $test->getName(false), 'triggering_file' => isset($deprecation[2]) ? $deprecation[2] : null));`
`276`	`276`	`if ($deprecation[0]) {`
`277`		`- trigger_error($error, E_USER_DEPRECATED);`
	`277`	`+ @trigger_error($error, E_USER_DEPRECATED);`
`278`	`278`	`} else {`
`279`	`279`	`@trigger_error($error, E_USER_DEPRECATED);`
`280`	`280`	`}`
`@@ -283,13 +283,13 @@ public function endTest($test, $time)`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`if ($this->expectedDeprecations) {`
`286`		`- if (!in_array($test->getStatus(), array($BaseTestRunner::STATUS_SKIPPED, $BaseTestRunner::STATUS_INCOMPLETE), true)) {`
`287`		`- $test->addToAssertionCount(count($this->expectedDeprecations));`
	`286`	`+ if (!\in_array($test->getStatus(), array($BaseTestRunner::STATUS_SKIPPED, $BaseTestRunner::STATUS_INCOMPLETE), true)) {`
	`287`	`+ $test->addToAssertionCount(\count($this->expectedDeprecations));`
`288`	`288`	`}`
`289`	`289`
`290`	`290`	`restore_error_handler();`
`291`	`291`
`292`		`- if (!$errored && !in_array($test->getStatus(), array($BaseTestRunner::STATUS_SKIPPED, $BaseTestRunner::STATUS_INCOMPLETE, $BaseTestRunner::STATUS_FAILURE, $BaseTestRunner::STATUS_ERROR), true)) {`
	`292`	`+ if (!$errored && !\in_array($test->getStatus(), array($BaseTestRunner::STATUS_SKIPPED, $BaseTestRunner::STATUS_INCOMPLETE, $BaseTestRunner::STATUS_FAILURE, $BaseTestRunner::STATUS_ERROR), true)) {`
`293`	`293`	`try {`
`294`	`294`	`$prefix = "@expectedDeprecation:\n";`
`295`	`295`	`$test->assertStringMatchesFormat($prefix.'%A '.implode("\n%A ", $this->expectedDeprecations)."\n%A", $prefix.' '.implode("\n ", $this->gatheredDeprecations)."\n");`
`@@ -303,24 +303,24 @@ public function endTest($test, $time)`
`303`	`303`	`$this->expectedDeprecations = $this->gatheredDeprecations = array();`
`304`	`304`	`$this->previousErrorHandler = null;`
`305`	`305`	`}`
`306`		`- if (!$this->runsInSeparateProcess && -2 < $this->state && ($test instanceof \PHPUnit_Framework_TestCase \|\| $test instanceof TestCase)) {`
`307`		`- if (in_array('time-sensitive', $groups, true)) {`
	`306`	`+ if (!$this->runsInSeparateProcess && -2 < $this->state && ($test instanceof \PHPUnit\Framework\TestCase \|\| $test instanceof TestCase)) {`
	`307`	`+ if (\in_array('time-sensitive', $groups, true)) {`
`308`	`308`	`ClockMock::withClockMock(false);`
`309`	`309`	`}`
`310`		`- if (in_array('dns-sensitive', $groups, true)) {`
	`310`	`+ if (\in_array('dns-sensitive', $groups, true)) {`
`311`	`311`	`DnsMock::withMockedHosts(array());`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`
`315`		`- if (($test instanceof \PHPUnit_Framework_TestCase \|\| $test instanceof TestCase) && 0 === strpos($test->getName(), 'testLegacy') && !isset($this->testsWithWarnings[$test->getName()]) && !in_array('legacy', $groups, true)) {`
	`315`	`+ if (($test instanceof \PHPUnit\Framework\TestCase \|\| $test instanceof TestCase) && 0 === strpos($test->getName(), 'testLegacy') && !isset($this->testsWithWarnings[$test->getName()]) && !\in_array('legacy', $groups, true)) {`
`316`	`316`	`$result = $test->getTestResultObject();`
`317`	`317`
`318`	`318`	`if (method_exists($result, 'addWarning')) {`
`319`	`319`	`$result->addWarning($test, new $Warning('Using the "testLegacy" prefix to mark tests as legacy is deprecated since version 3.3 and will be removed in 4.0. Use the "@group legacy" notation instead to add the test to the legacy group.'), $time);`
`320`	`320`	`}`
`321`	`321`	`}`
`322`	`322`
`323`		`- if (($test instanceof \PHPUnit_Framework_TestCase \|\| $test instanceof TestCase) && strpos($className, '\Legacy') && !isset($this->testsWithWarnings[$test->getName()]) && !in_array('legacy', $classGroups, true)) {`
	`323`	`+ if (($test instanceof \PHPUnit\Framework\TestCase \|\| $test instanceof TestCase) && strpos($className, '\Legacy') && !isset($this->testsWithWarnings[$test->getName()]) && !\in_array('legacy', $classGroups, true)) {`
`324`	`324`	`$result = $test->getTestResultObject();`
`325`	`325`
`326`	`326`	`if (method_exists($result, 'addWarning')) {`
`@@ -339,7 +339,7 @@ public function handleError($type, $msg, $file, $line, $context = array())`
`339`	`339`	`// If the message is serialized we need to extract the message. This occurs when the error is triggered by`
`340`	`340`	`// by the isolated test path in \Symfony\Bridge\PhpUnit\Legacy\SymfonyTestsListenerTrait::endTest().`
`341`	`341`	`$parsedMsg = @unserialize($msg);`
`342`		`- if (is_array($parsedMsg)) {`
	`342`	`+ if (\is_array($parsedMsg)) {`
`343`	`343`	`$msg = $parsedMsg['deprecation'];`
`344`	`344`	`}`
`345`	`345`	`if (error_reporting()) {`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public function test()`
`12`	`12`	`$this->markTestSkipped('This test cannot be run on Windows.');`
`13`	`13`	`}`
`14`	`14`
`15`		`- if (defined('HHVM_VERSION')) {`
	`15`	`+ if (\defined('HHVM_VERSION')) {`
`16`	`16`	`$this->markTestSkipped('This test cannot be run on HHVM.');`
`17`	`17`	`}`
`18`	`18`