First commit

vendor/symfony/debug/Tests/DebugClassLoaderTest.php

@@ -0,0 +1,425 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Debug\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Debug\DebugClassLoader;
+use Symfony\Component\Debug\ErrorHandler;
+
+class DebugClassLoaderTest extends TestCase
+{
+    /**
+     * @var int Error reporting level before running tests
+     */
+    private $errorReporting;
+
+    private $loader;
+
+    protected function setUp()
+    {
+        $this->errorReporting = error_reporting(E_ALL);
+        $this->loader = new ClassLoader();
+        spl_autoload_register(array($this->loader, 'loadClass'), true, true);
+        DebugClassLoader::enable();
+    }
+
+    protected function tearDown()
+    {
+        DebugClassLoader::disable();
+        spl_autoload_unregister(array($this->loader, 'loadClass'));
+        error_reporting($this->errorReporting);
+    }
+
+    public function testIdempotence()
+    {
+        DebugClassLoader::enable();
+
+        $functions = spl_autoload_functions();
+        foreach ($functions as $function) {
+            if (is_array($function) && $function[0] instanceof DebugClassLoader) {
+                $reflClass = new \ReflectionClass($function[0]);
+                $reflProp = $reflClass->getProperty('classLoader');
+                $reflProp->setAccessible(true);
+
+                $this->assertNotInstanceOf('Symfony\Component\Debug\DebugClassLoader', $reflProp->getValue($function[0]));
+
+                return;
+            }
+        }
+
+        $this->fail('DebugClassLoader did not register');
+    }
+
+    /**
+     * @expectedException \Exception
+     * @expectedExceptionMessage boo
+     */
+    public function testThrowingClass()
+    {
+        try {
+            class_exists(__NAMESPACE__.'\Fixtures\Throwing');
+            $this->fail('Exception expected');
+        } catch (\Exception $e) {
+            $this->assertSame('boo', $e->getMessage());
+        }
+
+        // the second call also should throw
+        class_exists(__NAMESPACE__.'\Fixtures\Throwing');
+    }
+
+    public function testUnsilencing()
+    {
+        if (\PHP_VERSION_ID >= 70000) {
+            $this->markTestSkipped('PHP7 throws exceptions, unsilencing is not required anymore.');
+        }
+        if (defined('HHVM_VERSION')) {
+            $this->markTestSkipped('HHVM is not handled in this test case.');
+        }
+
+        ob_start();
+
+        $this->iniSet('log_errors', 0);
+        $this->iniSet('display_errors', 1);
+
+        // See below: this will fail with parse error
+        // but this should not be @-silenced.
+        @class_exists(__NAMESPACE__.'\TestingUnsilencing', true);
+
+        $output = ob_get_clean();
+
+        $this->assertStringMatchesFormat('%aParse error%a', $output);
+    }
+
+    public function testStacking()
+    {
+        // the ContextErrorException must not be loaded to test the workaround
+        // for https://bugs.php.net/65322.
+        if (class_exists('Symfony\Component\Debug\Exception\ContextErrorException', false)) {
+            $this->markTestSkipped('The ContextErrorException class is already loaded.');
+        }
+        if (defined('HHVM_VERSION')) {
+            $this->markTestSkipped('HHVM is not handled in this test case.');
+        }
+
+        ErrorHandler::register();
+
+        try {
+            // Trigger autoloading + E_STRICT at compile time
+            // which in turn triggers $errorHandler->handle()
+            // that again triggers autoloading for ContextErrorException.
+            // Error stacking works around the bug above and everything is fine.
+
+            eval('
+                namespace '.__NAMESPACE__.';
+                class ChildTestingStacking extends TestingStacking { function foo($bar) {} }
+            ');
+            $this->fail('ContextErrorException expected');
+        } catch (\ErrorException $exception) {
+            // if an exception is thrown, the test passed
+            $this->assertStringStartsWith(__FILE__, $exception->getFile());
+            if (\PHP_VERSION_ID < 70000) {
+                $this->assertRegExp('/^Runtime Notice: Declaration/', $exception->getMessage());
+                $this->assertEquals(E_STRICT, $exception->getSeverity());
+            } else {
+                $this->assertRegExp('/^Warning: Declaration/', $exception->getMessage());
+                $this->assertEquals(E_WARNING, $exception->getSeverity());
+            }
+        } finally {
+            restore_error_handler();
+            restore_exception_handler();
+        }
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Case mismatch between loaded and declared class names
+     */
+    public function testNameCaseMismatch()
+    {
+        class_exists(__NAMESPACE__.'\TestingCaseMismatch', true);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Case mismatch between class and real file names
+     */
+    public function testFileCaseMismatch()
+    {
+        if (!file_exists(__DIR__.'/Fixtures/CaseMismatch.php')) {
+            $this->markTestSkipped('Can only be run on case insensitive filesystems');
+        }
+
+        class_exists(__NAMESPACE__.'\Fixtures\CaseMismatch', true);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Case mismatch between loaded and declared class names
+     */
+    public function testPsr4CaseMismatch()
+    {
+        class_exists(__NAMESPACE__.'\Fixtures\Psr4CaseMismatch', true);
+    }
+
+    public function testNotPsr0()
+    {
+        $this->assertTrue(class_exists(__NAMESPACE__.'\Fixtures\NotPSR0', true));
+    }
+
+    public function testNotPsr0Bis()
+    {
+        $this->assertTrue(class_exists(__NAMESPACE__.'\Fixtures\NotPSR0bis', true));
+    }
+
+    public function testClassAlias()
+    {
+        $this->assertTrue(class_exists(__NAMESPACE__.'\Fixtures\ClassAlias', true));
+    }
+
+    /**
+     * @dataProvider provideDeprecatedSuper
+     */
+    public function testDeprecatedSuper($class, $super, $type)
+    {
+        set_error_handler(function () { return false; });
+        $e = error_reporting(0);
+        trigger_error('', E_USER_DEPRECATED);
+
+        class_exists('Test\\'.__NAMESPACE__.'\\'.$class, true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $lastError = error_get_last();
+        unset($lastError['file'], $lastError['line']);
+
+        $xError = array(
+            'type' => E_USER_DEPRECATED,
+            'message' => 'The "Test\Symfony\Component\Debug\Tests\\'.$class.'" class '.$type.' "Symfony\Component\Debug\Tests\Fixtures\\'.$super.'" that is deprecated but this is a test deprecation notice.',
+        );
+
+        $this->assertSame($xError, $lastError);
+    }
+
+    public function provideDeprecatedSuper()
+    {
+        return array(
+            array('DeprecatedInterfaceClass', 'DeprecatedInterface', 'implements'),
+            array('DeprecatedParentClass', 'DeprecatedClass', 'extends'),
+        );
+    }
+
+    public function testInterfaceExtendsDeprecatedInterface()
+    {
+        set_error_handler(function () { return false; });
+        $e = error_reporting(0);
+        trigger_error('', E_USER_NOTICE);
+
+        class_exists('Test\\'.__NAMESPACE__.'\\NonDeprecatedInterfaceClass', true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $lastError = error_get_last();
+        unset($lastError['file'], $lastError['line']);
+
+        $xError = array(
+            'type' => E_USER_NOTICE,
+            'message' => '',
+        );
+
+        $this->assertSame($xError, $lastError);
+    }
+
+    public function testDeprecatedSuperInSameNamespace()
+    {
+        set_error_handler(function () { return false; });
+        $e = error_reporting(0);
+        trigger_error('', E_USER_NOTICE);
+
+        class_exists('Symfony\Bridge\Debug\Tests\Fixtures\ExtendsDeprecatedParent', true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $lastError = error_get_last();
+        unset($lastError['file'], $lastError['line']);
+
+        $xError = array(
+            'type' => E_USER_NOTICE,
+            'message' => '',
+        );
+
+        $this->assertSame($xError, $lastError);
+    }
+
+    public function testReservedForPhp7()
+    {
+        if (\PHP_VERSION_ID >= 70000) {
+            $this->markTestSkipped('PHP7 already prevents using reserved names.');
+        }
+
+        set_error_handler(function () { return false; });
+        $e = error_reporting(0);
+        trigger_error('', E_USER_NOTICE);
+
+        class_exists('Test\\'.__NAMESPACE__.'\\Float', true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $lastError = error_get_last();
+        unset($lastError['file'], $lastError['line']);
+
+        $xError = array(
+            'type' => E_USER_DEPRECATED,
+            'message' => 'The "Test\Symfony\Component\Debug\Tests\Float" class uses the reserved name "Float", it will break on PHP 7 and higher',
+        );
+
+        $this->assertSame($xError, $lastError);
+    }
+
+    public function testExtendedFinalClass()
+    {
+        set_error_handler(function () { return false; });
+        $e = error_reporting(0);
+        trigger_error('', E_USER_NOTICE);
+
+        class_exists('Test\\'.__NAMESPACE__.'\\ExtendsFinalClass', true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $lastError = error_get_last();
+        unset($lastError['file'], $lastError['line']);
+
+        $xError = array(
+            'type' => E_USER_DEPRECATED,
+            'message' => 'The "Symfony\Component\Debug\Tests\Fixtures\FinalClass" class is considered final since version 3.3. It may change without further notice as of its next major version. You should not extend it from "Test\Symfony\Component\Debug\Tests\ExtendsFinalClass".',
+        );
+
+        $this->assertSame($xError, $lastError);
+    }
+
+    public function testExtendedFinalMethod()
+    {
+        set_error_handler(function () { return false; });
+        $e = error_reporting(0);
+        trigger_error('', E_USER_NOTICE);
+
+        class_exists(__NAMESPACE__.'\\Fixtures\\ExtendedFinalMethod', true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $lastError = error_get_last();
+        unset($lastError['file'], $lastError['line']);
+
+        $xError = array(
+            'type' => E_USER_DEPRECATED,
+            'message' => 'The "Symfony\Component\Debug\Tests\Fixtures\FinalMethod::finalMethod()" method is considered final since version 3.3. It may change without further notice as of its next major version. You should not extend it from "Symfony\Component\Debug\Tests\Fixtures\ExtendedFinalMethod".',
+        );
+
+        $this->assertSame($xError, $lastError);
+    }
+
+    public function testExtendedDeprecatedMethodDoesntTriggerAnyNotice()
+    {
+        set_error_handler(function () { return false; });
+        $e = error_reporting(0);
+        trigger_error('', E_USER_NOTICE);
+
+        class_exists('Test\\'.__NAMESPACE__.'\\ExtendsAnnotatedClass', true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $lastError = error_get_last();
+        unset($lastError['file'], $lastError['line']);
+
+        $this->assertSame(array('type' => E_USER_NOTICE, 'message' => ''), $lastError);
+    }
+
+    public function testInternalsUse()
+    {
+        $deprecations = array();
+        set_error_handler(function ($type, $msg) use (&$deprecations) { $deprecations[] = $msg; });
+        $e = error_reporting(E_USER_DEPRECATED);
+
+        class_exists('Test\\'.__NAMESPACE__.'\\ExtendsInternals', true);
+
+        error_reporting($e);
+        restore_error_handler();
+
+        $this->assertSame($deprecations, array(
+            'The "Symfony\Component\Debug\Tests\Fixtures\InternalClass" class is considered internal since version 3.4. It may change without further notice. You should not use it from "Test\Symfony\Component\Debug\Tests\ExtendsInternalsParent".',
+            'The "Symfony\Component\Debug\Tests\Fixtures\InternalInterface" interface is considered internal. It may change without further notice. You should not use it from "Test\Symfony\Component\Debug\Tests\ExtendsInternalsParent".',
+            'The "Symfony\Component\Debug\Tests\Fixtures\InternalTrait" trait is considered internal. It may change without further notice. You should not use it from "Test\Symfony\Component\Debug\Tests\ExtendsInternals".',
+            'The "Symfony\Component\Debug\Tests\Fixtures\InternalTrait2::internalMethod()" method is considered internal since version 3.4. It may change without further notice. You should not extend it from "Test\Symfony\Component\Debug\Tests\ExtendsInternals".',
+        ));
+    }
+}
+
+class ClassLoader
+{
+    public function loadClass($class)
+    {
+    }
+
+    public function getClassMap()
+    {
+        return array(__NAMESPACE__.'\Fixtures\NotPSR0bis' => __DIR__.'/Fixtures/notPsr0Bis.php');
+    }
+
+    public function findFile($class)
+    {
+        $fixtureDir = __DIR__.DIRECTORY_SEPARATOR.'Fixtures'.DIRECTORY_SEPARATOR;
+
+        if (__NAMESPACE__.'\TestingUnsilencing' === $class) {
+            eval('-- parse error --');
+        } elseif (__NAMESPACE__.'\TestingStacking' === $class) {
+            eval('namespace '.__NAMESPACE__.'; class TestingStacking { function foo() {} }');
+        } elseif (__NAMESPACE__.'\TestingCaseMismatch' === $class) {
+            eval('namespace '.__NAMESPACE__.'; class TestingCaseMisMatch {}');
+        } elseif (__NAMESPACE__.'\Fixtures\Psr4CaseMismatch' === $class) {
+            return $fixtureDir.'psr4'.DIRECTORY_SEPARATOR.'Psr4CaseMismatch.php';
+        } elseif (__NAMESPACE__.'\Fixtures\NotPSR0' === $class) {
+            return $fixtureDir.'reallyNotPsr0.php';
+        } elseif (__NAMESPACE__.'\Fixtures\NotPSR0bis' === $class) {
+            return $fixtureDir.'notPsr0Bis.php';
+        } elseif ('Symfony\Bridge\Debug\Tests\Fixtures\ExtendsDeprecatedParent' === $class) {
+            eval('namespace Symfony\Bridge\Debug\Tests\Fixtures; class ExtendsDeprecatedParent extends \\'.__NAMESPACE__.'\Fixtures\DeprecatedClass {}');
+        } elseif ('Test\\'.__NAMESPACE__.'\DeprecatedParentClass' === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class DeprecatedParentClass extends \\'.__NAMESPACE__.'\Fixtures\DeprecatedClass {}');
+        } elseif ('Test\\'.__NAMESPACE__.'\DeprecatedInterfaceClass' === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class DeprecatedInterfaceClass implements \\'.__NAMESPACE__.'\Fixtures\DeprecatedInterface {}');
+        } elseif ('Test\\'.__NAMESPACE__.'\NonDeprecatedInterfaceClass' === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class NonDeprecatedInterfaceClass implements \\'.__NAMESPACE__.'\Fixtures\NonDeprecatedInterface {}');
+        } elseif ('Test\\'.__NAMESPACE__.'\Float' === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class Float {}');
+        } elseif ('Test\\'.__NAMESPACE__.'\ExtendsFinalClass' === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsFinalClass extends \\'.__NAMESPACE__.'\Fixtures\FinalClass {}');
+        } elseif ('Test\\'.__NAMESPACE__.'\ExtendsAnnotatedClass' === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsAnnotatedClass extends \\'.__NAMESPACE__.'\Fixtures\AnnotatedClass {
+                public function deprecatedMethod() { }
+            }');
+        } elseif ('Test\\'.__NAMESPACE__.'\ExtendsInternals' === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsInternals extends ExtendsInternalsParent {
+                use \\'.__NAMESPACE__.'\Fixtures\InternalTrait;
+
+                public function internalMethod() { }
+            }');
+        } elseif ('Test\\'.__NAMESPACE__.'\ExtendsInternalsParent' === $class) {
+            eval('namespace Test\\'.__NAMESPACE__.'; class ExtendsInternalsParent extends \\'.__NAMESPACE__.'\Fixtures\InternalClass implements \\'.__NAMESPACE__.'\Fixtures\InternalInterface { }');
+        }
+    }
+}

vendor/symfony/debug/Tests/ErrorHandlerTest.php

@@ -0,0 +1,536 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Debug\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LogLevel;
+use Symfony\Component\Debug\BufferingLogger;
+use Symfony\Component\Debug\ErrorHandler;
+use Symfony\Component\Debug\Exception\SilencedErrorContext;
+
+/**
+ * ErrorHandlerTest.
+ *
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class ErrorHandlerTest extends TestCase
+{
+    public function testRegister()
+    {
+        $handler = ErrorHandler::register();
+
+        try {
+            $this->assertInstanceOf('Symfony\Component\Debug\ErrorHandler', $handler);
+            $this->assertSame($handler, ErrorHandler::register());
+
+            $newHandler = new ErrorHandler();
+
+            $this->assertSame($newHandler, ErrorHandler::register($newHandler, false));
+            $h = set_error_handler('var_dump');
+            restore_error_handler();
+            $this->assertSame(array($handler, 'handleError'), $h);
+
+            try {
+                $this->assertSame($newHandler, ErrorHandler::register($newHandler, true));
+                $h = set_error_handler('var_dump');
+                restore_error_handler();
+                $this->assertSame(array($newHandler, 'handleError'), $h);
+            } catch (\Exception $e) {
+            }
+
+            restore_error_handler();
+            restore_exception_handler();
+
+            if (isset($e)) {
+                throw $e;
+            }
+        } catch (\Exception $e) {
+        }
+
+        restore_error_handler();
+        restore_exception_handler();
+
+        if (isset($e)) {
+            throw $e;
+        }
+    }
+
+    public function testNotice()
+    {
+        ErrorHandler::register();
+
+        try {
+            self::triggerNotice($this);
+            $this->fail('ErrorException expected');
+        } catch (\ErrorException $exception) {
+            // if an exception is thrown, the test passed
+            $this->assertEquals(E_NOTICE, $exception->getSeverity());
+            $this->assertEquals(__FILE__, $exception->getFile());
+            $this->assertRegExp('/^Notice: Undefined variable: (foo|bar)/', $exception->getMessage());
+
+            $trace = $exception->getTrace();
+
+            $this->assertEquals(__FILE__, $trace[0]['file']);
+            $this->assertEquals(__CLASS__, $trace[0]['class']);
+            $this->assertEquals('triggerNotice', $trace[0]['function']);
+            $this->assertEquals('::', $trace[0]['type']);
+
+            $this->assertEquals(__FILE__, $trace[0]['file']);
+            $this->assertEquals(__CLASS__, $trace[1]['class']);
+            $this->assertEquals(__FUNCTION__, $trace[1]['function']);
+            $this->assertEquals('->', $trace[1]['type']);
+        } finally {
+            restore_error_handler();
+            restore_exception_handler();
+        }
+    }
+
+    // dummy function to test trace in error handler.
+    private static function triggerNotice($that)
+    {
+        $that->assertSame('', $foo.$foo.$bar);
+    }
+
+    public function testConstruct()
+    {
+        try {
+            $handler = ErrorHandler::register();
+            $handler->throwAt(3, true);
+            $this->assertEquals(3 | E_RECOVERABLE_ERROR | E_USER_ERROR, $handler->throwAt(0));
+        } finally {
+            restore_error_handler();
+            restore_exception_handler();
+        }
+    }
+
+    public function testDefaultLogger()
+    {
+        try {
+            $handler = ErrorHandler::register();
+
+            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+
+            $handler->setDefaultLogger($logger, E_NOTICE);
+            $handler->setDefaultLogger($logger, array(E_USER_NOTICE => LogLevel::CRITICAL));
+
+            $loggers = array(
+                E_DEPRECATED => array(null, LogLevel::INFO),
+                E_USER_DEPRECATED => array(null, LogLevel::INFO),
+                E_NOTICE => array($logger, LogLevel::WARNING),
+                E_USER_NOTICE => array($logger, LogLevel::CRITICAL),
+                E_STRICT => array(null, LogLevel::WARNING),
+                E_WARNING => array(null, LogLevel::WARNING),
+                E_USER_WARNING => array(null, LogLevel::WARNING),
+                E_COMPILE_WARNING => array(null, LogLevel::WARNING),
+                E_CORE_WARNING => array(null, LogLevel::WARNING),
+                E_USER_ERROR => array(null, LogLevel::CRITICAL),
+                E_RECOVERABLE_ERROR => array(null, LogLevel::CRITICAL),
+                E_COMPILE_ERROR => array(null, LogLevel::CRITICAL),
+                E_PARSE => array(null, LogLevel::CRITICAL),
+                E_ERROR => array(null, LogLevel::CRITICAL),
+                E_CORE_ERROR => array(null, LogLevel::CRITICAL),
+            );
+            $this->assertSame($loggers, $handler->setLoggers(array()));
+        } finally {
+            restore_error_handler();
+            restore_exception_handler();
+        }
+    }
+
+    public function testHandleError()
+    {
+        try {
+            $handler = ErrorHandler::register();
+            $handler->throwAt(0, true);
+            $this->assertFalse($handler->handleError(0, 'foo', 'foo.php', 12, array()));
+
+            restore_error_handler();
+            restore_exception_handler();
+
+            $handler = ErrorHandler::register();
+            $handler->throwAt(3, true);
+            $this->assertFalse($handler->handleError(4, 'foo', 'foo.php', 12, array()));
+
+            restore_error_handler();
+            restore_exception_handler();
+
+            $handler = ErrorHandler::register();
+            $handler->throwAt(3, true);
+            try {
+                $handler->handleError(4, 'foo', 'foo.php', 12, array());
+            } catch (\ErrorException $e) {
+                $this->assertSame('Parse Error: foo', $e->getMessage());
+                $this->assertSame(4, $e->getSeverity());
+                $this->assertSame('foo.php', $e->getFile());
+                $this->assertSame(12, $e->getLine());
+            }
+
+            restore_error_handler();
+            restore_exception_handler();
+
+            $handler = ErrorHandler::register();
+            $handler->throwAt(E_USER_DEPRECATED, true);
+            $this->assertFalse($handler->handleError(E_USER_DEPRECATED, 'foo', 'foo.php', 12, array()));
+
+            restore_error_handler();
+            restore_exception_handler();
+
+            $handler = ErrorHandler::register();
+            $handler->throwAt(E_DEPRECATED, true);
+            $this->assertFalse($handler->handleError(E_DEPRECATED, 'foo', 'foo.php', 12, array()));
+
+            restore_error_handler();
+            restore_exception_handler();
+
+            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+
+            $warnArgCheck = function ($logLevel, $message, $context) {
+                $this->assertEquals('info', $logLevel);
+                $this->assertEquals('User Deprecated: foo', $message);
+                $this->assertArrayHasKey('exception', $context);
+                $exception = $context['exception'];
+                $this->assertInstanceOf(\ErrorException::class, $exception);
+                $this->assertSame('User Deprecated: foo', $exception->getMessage());
+                $this->assertSame(E_USER_DEPRECATED, $exception->getSeverity());
+            };
+
+            $logger
+                ->expects($this->once())
+                ->method('log')
+                ->will($this->returnCallback($warnArgCheck))
+            ;
+
+            $handler = ErrorHandler::register();
+            $handler->setDefaultLogger($logger, E_USER_DEPRECATED);
+            $this->assertTrue($handler->handleError(E_USER_DEPRECATED, 'foo', 'foo.php', 12, array()));
+
+            restore_error_handler();
+            restore_exception_handler();
+
+            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+
+            $line = null;
+            $logArgCheck = function ($level, $message, $context) use (&$line) {
+                $this->assertEquals('Notice: Undefined variable: undefVar', $message);
+                $this->assertArrayHasKey('exception', $context);
+                $exception = $context['exception'];
+                $this->assertInstanceOf(SilencedErrorContext::class, $exception);
+                $this->assertSame(E_NOTICE, $exception->getSeverity());
+                $this->assertSame(__FILE__, $exception->getFile());
+                $this->assertSame($line, $exception->getLine());
+                $this->assertNotEmpty($exception->getTrace());
+                $this->assertSame(1, $exception->count);
+            };
+
+            $logger
+                ->expects($this->once())
+                ->method('log')
+                ->will($this->returnCallback($logArgCheck))
+            ;
+
+            $handler = ErrorHandler::register();
+            $handler->setDefaultLogger($logger, E_NOTICE);
+            $handler->screamAt(E_NOTICE);
+            unset($undefVar);
+            $line = __LINE__ + 1;
+            @$undefVar++;
+
+            restore_error_handler();
+            restore_exception_handler();
+        } catch (\Exception $e) {
+            restore_error_handler();
+            restore_exception_handler();
+
+            throw $e;
+        }
+    }
+
+    public function testHandleUserError()
+    {
+        try {
+            $handler = ErrorHandler::register();
+            $handler->throwAt(0, true);
+
+            $e = null;
+            $x = new \Exception('Foo');
+
+            try {
+                $f = new Fixtures\ToStringThrower($x);
+                $f .= ''; // Trigger $f->__toString()
+            } catch (\Exception $e) {
+            }
+
+            $this->assertSame($x, $e);
+        } finally {
+            restore_error_handler();
+            restore_exception_handler();
+        }
+    }
+
+    public function testHandleDeprecation()
+    {
+        $logArgCheck = function ($level, $message, $context) {
+            $this->assertEquals(LogLevel::INFO, $level);
+            $this->assertArrayHasKey('exception', $context);
+            $exception = $context['exception'];
+            $this->assertInstanceOf(\ErrorException::class, $exception);
+            $this->assertSame('User Deprecated: Foo deprecation', $exception->getMessage());
+        };
+
+        $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+        $logger
+            ->expects($this->once())
+            ->method('log')
+            ->will($this->returnCallback($logArgCheck))
+        ;
+
+        $handler = new ErrorHandler();
+        $handler->setDefaultLogger($logger);
+        @$handler->handleError(E_USER_DEPRECATED, 'Foo deprecation', __FILE__, __LINE__, array());
+    }
+
+    public function testHandleException()
+    {
+        try {
+            $handler = ErrorHandler::register();
+
+            $exception = new \Exception('foo');
+
+            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+
+            $logArgCheck = function ($level, $message, $context) {
+                $this->assertSame('Uncaught Exception: foo', $message);
+                $this->assertArrayHasKey('exception', $context);
+                $this->assertInstanceOf(\Exception::class, $context['exception']);
+            };
+
+            $logger
+                ->expects($this->exactly(2))
+                ->method('log')
+                ->will($this->returnCallback($logArgCheck))
+            ;
+
+            $handler->setDefaultLogger($logger, E_ERROR);
+
+            try {
+                $handler->handleException($exception);
+                $this->fail('Exception expected');
+            } catch (\Exception $e) {
+                $this->assertSame($exception, $e);
+            }
+
+            $handler->setExceptionHandler(function ($e) use ($exception) {
+                $this->assertSame($exception, $e);
+            });
+
+            $handler->handleException($exception);
+        } finally {
+            restore_error_handler();
+            restore_exception_handler();
+        }
+    }
+
+    /**
+     * @group legacy
+     */
+    public function testErrorStacking()
+    {
+        try {
+            $handler = ErrorHandler::register();
+            $handler->screamAt(E_USER_WARNING);
+
+            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+
+            $logger
+                ->expects($this->exactly(2))
+                ->method('log')
+                ->withConsecutive(
+                    array($this->equalTo(LogLevel::WARNING), $this->equalTo('Dummy log')),
+                    array($this->equalTo(LogLevel::DEBUG), $this->equalTo('User Warning: Silenced warning'))
+                )
+            ;
+
+            $handler->setDefaultLogger($logger, array(E_USER_WARNING => LogLevel::WARNING));
+
+            ErrorHandler::stackErrors();
+            @trigger_error('Silenced warning', E_USER_WARNING);
+            $logger->log(LogLevel::WARNING, 'Dummy log');
+            ErrorHandler::unstackErrors();
+        } finally {
+            restore_error_handler();
+            restore_exception_handler();
+        }
+    }
+
+    public function testBootstrappingLogger()
+    {
+        $bootLogger = new BufferingLogger();
+        $handler = new ErrorHandler($bootLogger);
+
+        $loggers = array(
+            E_DEPRECATED => array($bootLogger, LogLevel::INFO),
+            E_USER_DEPRECATED => array($bootLogger, LogLevel::INFO),
+            E_NOTICE => array($bootLogger, LogLevel::WARNING),
+            E_USER_NOTICE => array($bootLogger, LogLevel::WARNING),
+            E_STRICT => array($bootLogger, LogLevel::WARNING),
+            E_WARNING => array($bootLogger, LogLevel::WARNING),
+            E_USER_WARNING => array($bootLogger, LogLevel::WARNING),
+            E_COMPILE_WARNING => array($bootLogger, LogLevel::WARNING),
+            E_CORE_WARNING => array($bootLogger, LogLevel::WARNING),
+            E_USER_ERROR => array($bootLogger, LogLevel::CRITICAL),
+            E_RECOVERABLE_ERROR => array($bootLogger, LogLevel::CRITICAL),
+            E_COMPILE_ERROR => array($bootLogger, LogLevel::CRITICAL),
+            E_PARSE => array($bootLogger, LogLevel::CRITICAL),
+            E_ERROR => array($bootLogger, LogLevel::CRITICAL),
+            E_CORE_ERROR => array($bootLogger, LogLevel::CRITICAL),
+        );
+
+        $this->assertSame($loggers, $handler->setLoggers(array()));
+
+        $handler->handleError(E_DEPRECATED, 'Foo message', __FILE__, 123, array());
+
+        $logs = $bootLogger->cleanLogs();
+
+        $this->assertCount(1, $logs);
+        $log = $logs[0];
+        $this->assertSame('info', $log[0]);
+        $this->assertSame('Deprecated: Foo message', $log[1]);
+        $this->assertArrayHasKey('exception', $log[2]);
+        $exception = $log[2]['exception'];
+        $this->assertInstanceOf(\ErrorException::class, $exception);
+        $this->assertSame('Deprecated: Foo message', $exception->getMessage());
+        $this->assertSame(__FILE__, $exception->getFile());
+        $this->assertSame(123, $exception->getLine());
+        $this->assertSame(E_DEPRECATED, $exception->getSeverity());
+
+        $bootLogger->log(LogLevel::WARNING, 'Foo message', array('exception' => $exception));
+
+        $mockLogger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+        $mockLogger->expects($this->once())
+            ->method('log')
+            ->with(LogLevel::WARNING, 'Foo message', array('exception' => $exception));
+
+        $handler->setLoggers(array(E_DEPRECATED => array($mockLogger, LogLevel::WARNING)));
+    }
+
+    public function testSettingLoggerWhenExceptionIsBuffered()
+    {
+        $bootLogger = new BufferingLogger();
+        $handler = new ErrorHandler($bootLogger);
+
+        $exception = new \Exception('Foo message');
+
+        $mockLogger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+        $mockLogger->expects($this->once())
+            ->method('log')
+            ->with(LogLevel::CRITICAL, 'Uncaught Exception: Foo message', array('exception' => $exception));
+
+        $handler->setExceptionHandler(function () use ($handler, $mockLogger) {
+            $handler->setDefaultLogger($mockLogger);
+        });
+
+        $handler->handleException($exception);
+    }
+
+    public function testHandleFatalError()
+    {
+        try {
+            $handler = ErrorHandler::register();
+
+            $error = array(
+                'type' => E_PARSE,
+                'message' => 'foo',
+                'file' => 'bar',
+                'line' => 123,
+            );
+
+            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+
+            $logArgCheck = function ($level, $message, $context) {
+                $this->assertEquals('Fatal Parse Error: foo', $message);
+                $this->assertArrayHasKey('exception', $context);
+                $this->assertInstanceOf(\Exception::class, $context['exception']);
+            };
+
+            $logger
+                ->expects($this->once())
+                ->method('log')
+                ->will($this->returnCallback($logArgCheck))
+            ;
+
+            $handler->setDefaultLogger($logger, E_PARSE);
+
+            $handler->handleFatalError($error);
+
+            restore_error_handler();
+            restore_exception_handler();
+        } catch (\Exception $e) {
+            restore_error_handler();
+            restore_exception_handler();
+
+            throw $e;
+        }
+    }
+
+    /**
+     * @requires PHP 7
+     */
+    public function testHandleErrorException()
+    {
+        $exception = new \Error("Class 'Foo' not found");
+
+        $handler = new ErrorHandler();
+        $handler->setExceptionHandler(function () use (&$args) {
+            $args = func_get_args();
+        });
+
+        $handler->handleException($exception);
+
+        $this->assertInstanceOf('Symfony\Component\Debug\Exception\ClassNotFoundException', $args[0]);
+        $this->assertStringStartsWith("Attempted to load class \"Foo\" from the global namespace.\nDid you forget a \"use\" statement", $args[0]->getMessage());
+    }
+
+    public function testHandleFatalErrorOnHHVM()
+    {
+        try {
+            $handler = ErrorHandler::register();
+
+            $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
+            $logger
+                ->expects($this->once())
+                ->method('log')
+                ->with(
+                    $this->equalTo(LogLevel::CRITICAL),
+                    $this->equalTo('Fatal Error: foo')
+                )
+            ;
+
+            $handler->setDefaultLogger($logger, E_ERROR);
+
+            $error = array(
+                'type' => E_ERROR + 0x1000000, // This error level is used by HHVM for fatal errors
+                'message' => 'foo',
+                'file' => 'bar',
+                'line' => 123,
+                'context' => array(123),
+                'backtrace' => array(456),
+            );
+
+            call_user_func_array(array($handler, 'handleError'), $error);
+            $handler->handleFatalError($error);
+        } finally {
+            restore_error_handler();
+            restore_exception_handler();
+        }
+    }
+}

vendor/symfony/debug/Tests/Exception/FlattenExceptionTest.php

@@ -0,0 +1,302 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Debug\Tests\Exception;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Debug\Exception\FlattenException;
+use Symfony\Component\HttpFoundation\Exception\SuspiciousOperationException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
+use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;
+use Symfony\Component\HttpKernel\Exception\ConflictHttpException;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\GoneHttpException;
+use Symfony\Component\HttpKernel\Exception\LengthRequiredHttpException;
+use Symfony\Component\HttpKernel\Exception\PreconditionFailedHttpException;
+use Symfony\Component\HttpKernel\Exception\PreconditionRequiredHttpException;
+use Symfony\Component\HttpKernel\Exception\ServiceUnavailableHttpException;
+use Symfony\Component\HttpKernel\Exception\TooManyRequestsHttpException;
+use Symfony\Component\HttpKernel\Exception\UnsupportedMediaTypeHttpException;
+
+class FlattenExceptionTest extends TestCase
+{
+    public function testStatusCode()
+    {
+        $flattened = FlattenException::create(new \RuntimeException(), 403);
+        $this->assertEquals('403', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new \RuntimeException());
+        $this->assertEquals('500', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new NotFoundHttpException());
+        $this->assertEquals('404', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new UnauthorizedHttpException('Basic realm="My Realm"'));
+        $this->assertEquals('401', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new BadRequestHttpException());
+        $this->assertEquals('400', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new NotAcceptableHttpException());
+        $this->assertEquals('406', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new ConflictHttpException());
+        $this->assertEquals('409', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new MethodNotAllowedHttpException(array('POST')));
+        $this->assertEquals('405', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new AccessDeniedHttpException());
+        $this->assertEquals('403', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new GoneHttpException());
+        $this->assertEquals('410', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new LengthRequiredHttpException());
+        $this->assertEquals('411', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new PreconditionFailedHttpException());
+        $this->assertEquals('412', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new PreconditionRequiredHttpException());
+        $this->assertEquals('428', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new ServiceUnavailableHttpException());
+        $this->assertEquals('503', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new TooManyRequestsHttpException());
+        $this->assertEquals('429', $flattened->getStatusCode());
+
+        $flattened = FlattenException::create(new UnsupportedMediaTypeHttpException());
+        $this->assertEquals('415', $flattened->getStatusCode());
+
+        if (class_exists(SuspiciousOperationException::class)) {
+            $flattened = FlattenException::create(new SuspiciousOperationException());
+            $this->assertEquals('400', $flattened->getStatusCode());
+        }
+    }
+
+    public function testHeadersForHttpException()
+    {
+        $flattened = FlattenException::create(new MethodNotAllowedHttpException(array('POST')));
+        $this->assertEquals(array('Allow' => 'POST'), $flattened->getHeaders());
+
+        $flattened = FlattenException::create(new UnauthorizedHttpException('Basic realm="My Realm"'));
+        $this->assertEquals(array('WWW-Authenticate' => 'Basic realm="My Realm"'), $flattened->getHeaders());
+
+        $flattened = FlattenException::create(new ServiceUnavailableHttpException('Fri, 31 Dec 1999 23:59:59 GMT'));
+        $this->assertEquals(array('Retry-After' => 'Fri, 31 Dec 1999 23:59:59 GMT'), $flattened->getHeaders());
+
+        $flattened = FlattenException::create(new ServiceUnavailableHttpException(120));
+        $this->assertEquals(array('Retry-After' => 120), $flattened->getHeaders());
+
+        $flattened = FlattenException::create(new TooManyRequestsHttpException('Fri, 31 Dec 1999 23:59:59 GMT'));
+        $this->assertEquals(array('Retry-After' => 'Fri, 31 Dec 1999 23:59:59 GMT'), $flattened->getHeaders());
+
+        $flattened = FlattenException::create(new TooManyRequestsHttpException(120));
+        $this->assertEquals(array('Retry-After' => 120), $flattened->getHeaders());
+    }
+
+    /**
+     * @dataProvider flattenDataProvider
+     */
+    public function testFlattenHttpException(\Exception $exception, $statusCode)
+    {
+        $flattened = FlattenException::create($exception);
+        $flattened2 = FlattenException::create($exception);
+
+        $flattened->setPrevious($flattened2);
+
+        $this->assertEquals($exception->getMessage(), $flattened->getMessage(), 'The message is copied from the original exception.');
+        $this->assertEquals($exception->getCode(), $flattened->getCode(), 'The code is copied from the original exception.');
+        $this->assertInstanceOf($flattened->getClass(), $exception, 'The class is set to the class of the original exception');
+    }
+
+    /**
+     * @dataProvider flattenDataProvider
+     */
+    public function testPrevious(\Exception $exception, $statusCode)
+    {
+        $flattened = FlattenException::create($exception);
+        $flattened2 = FlattenException::create($exception);
+
+        $flattened->setPrevious($flattened2);
+
+        $this->assertSame($flattened2, $flattened->getPrevious());
+
+        $this->assertSame(array($flattened2), $flattened->getAllPrevious());
+    }
+
+    /**
+     * @requires PHP 7.0
+     */
+    public function testPreviousError()
+    {
+        $exception = new \Exception('test', 123, new \ParseError('Oh noes!', 42));
+
+        $flattened = FlattenException::create($exception)->getPrevious();
+
+        $this->assertEquals($flattened->getMessage(), 'Parse error: Oh noes!', 'The message is copied from the original exception.');
+        $this->assertEquals($flattened->getCode(), 42, 'The code is copied from the original exception.');
+        $this->assertEquals($flattened->getClass(), 'Symfony\Component\Debug\Exception\FatalThrowableError', 'The class is set to the class of the original exception');
+    }
+
+    /**
+     * @dataProvider flattenDataProvider
+     */
+    public function testLine(\Exception $exception)
+    {
+        $flattened = FlattenException::create($exception);
+        $this->assertSame($exception->getLine(), $flattened->getLine());
+    }
+
+    /**
+     * @dataProvider flattenDataProvider
+     */
+    public function testFile(\Exception $exception)
+    {
+        $flattened = FlattenException::create($exception);
+        $this->assertSame($exception->getFile(), $flattened->getFile());
+    }
+
+    /**
+     * @dataProvider flattenDataProvider
+     */
+    public function testToArray(\Exception $exception, $statusCode)
+    {
+        $flattened = FlattenException::create($exception);
+        $flattened->setTrace(array(), 'foo.php', 123);
+
+        $this->assertEquals(array(
+            array(
+                'message' => 'test',
+                'class' => 'Exception',
+                'trace' => array(array(
+                    'namespace' => '', 'short_class' => '', 'class' => '', 'type' => '', 'function' => '', 'file' => 'foo.php', 'line' => 123,
+                    'args' => array(),
+                )),
+            ),
+        ), $flattened->toArray());
+    }
+
+    public function flattenDataProvider()
+    {
+        return array(
+            array(new \Exception('test', 123), 500),
+        );
+    }
+
+    public function testArguments()
+    {
+        $dh = opendir(__DIR__);
+        $fh = tmpfile();
+
+        $incomplete = unserialize('O:14:"BogusTestClass":0:{}');
+
+        $exception = $this->createException(array(
+            (object) array('foo' => 1),
+            new NotFoundHttpException(),
+            $incomplete,
+            $dh,
+            $fh,
+            function () {},
+            array(1, 2),
+            array('foo' => 123),
+            null,
+            true,
+            false,
+            0,
+            0.0,
+            '0',
+            '',
+            INF,
+            NAN,
+        ));
+
+        $flattened = FlattenException::create($exception);
+        $trace = $flattened->getTrace();
+        $args = $trace[1]['args'];
+        $array = $args[0][1];
+
+        closedir($dh);
+        fclose($fh);
+
+        $i = 0;
+        $this->assertSame(array('object', 'stdClass'), $array[$i++]);
+        $this->assertSame(array('object', 'Symfony\Component\HttpKernel\Exception\NotFoundHttpException'), $array[$i++]);
+        $this->assertSame(array('incomplete-object', 'BogusTestClass'), $array[$i++]);
+        $this->assertSame(array('resource', defined('HHVM_VERSION') ? 'Directory' : 'stream'), $array[$i++]);
+        $this->assertSame(array('resource', 'stream'), $array[$i++]);
+
+        $args = $array[$i++];
+        $this->assertSame($args[0], 'object');
+        $this->assertTrue('Closure' === $args[1] || is_subclass_of($args[1], '\Closure'), 'Expect object class name to be Closure or a subclass of Closure.');
+
+        $this->assertSame(array('array', array(array('integer', 1), array('integer', 2))), $array[$i++]);
+        $this->assertSame(array('array', array('foo' => array('integer', 123))), $array[$i++]);
+        $this->assertSame(array('null', null), $array[$i++]);
+        $this->assertSame(array('boolean', true), $array[$i++]);
+        $this->assertSame(array('boolean', false), $array[$i++]);
+        $this->assertSame(array('integer', 0), $array[$i++]);
+        $this->assertSame(array('float', 0.0), $array[$i++]);
+        $this->assertSame(array('string', '0'), $array[$i++]);
+        $this->assertSame(array('string', ''), $array[$i++]);
+        $this->assertSame(array('float', INF), $array[$i++]);
+
+        // assertEquals() does not like NAN values.
+        $this->assertEquals($array[$i][0], 'float');
+        $this->assertTrue(is_nan($array[$i++][1]));
+    }
+
+    public function testRecursionInArguments()
+    {
+        $a = null;
+        $a = array('foo', array(2, &$a));
+        $exception = $this->createException($a);
+
+        $flattened = FlattenException::create($exception);
+        $trace = $flattened->getTrace();
+        $this->assertContains('*DEEP NESTED ARRAY*', serialize($trace));
+    }
+
+    public function testTooBigArray()
+    {
+        $a = array();
+        for ($i = 0; $i < 20; ++$i) {
+            for ($j = 0; $j < 50; ++$j) {
+                for ($k = 0; $k < 10; ++$k) {
+                    $a[$i][$j][$k] = 'value';
+                }
+            }
+        }
+        $a[20] = 'value';
+        $a[21] = 'value1';
+        $exception = $this->createException($a);
+
+        $flattened = FlattenException::create($exception);
+        $trace = $flattened->getTrace();
+
+        $this->assertSame($trace[1]['args'][0], array('array', array('array', '*SKIPPED over 10000 entries*')));
+
+        $serializeTrace = serialize($trace);
+
+        $this->assertContains('*SKIPPED over 10000 entries*', $serializeTrace);
+        $this->assertNotContains('*value1*', $serializeTrace);
+    }
+
+    private function createException($foo)
+    {
+        return new \Exception();
+    }
+}

vendor/symfony/debug/Tests/ExceptionHandlerTest.php

@@ -0,0 +1,133 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Debug\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Debug\ExceptionHandler;
+use Symfony\Component\Debug\Exception\OutOfMemoryException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
+
+require_once __DIR__.'/HeaderMock.php';
+
+class ExceptionHandlerTest extends TestCase
+{
+    protected function setUp()
+    {
+        testHeader();
+    }
+
+    protected function tearDown()
+    {
+        testHeader();
+    }
+
+    public function testDebug()
+    {
+        $handler = new ExceptionHandler(false);
+
+        ob_start();
+        $handler->sendPhpResponse(new \RuntimeException('Foo'));
+        $response = ob_get_clean();
+
+        $this->assertContains('Whoops, looks like something went wrong.', $response);
+        $this->assertNotContains('<div class="trace trace-as-html">', $response);
+
+        $handler = new ExceptionHandler(true);
+
+        ob_start();
+        $handler->sendPhpResponse(new \RuntimeException('Foo'));
+        $response = ob_get_clean();
+
+        $this->assertContains('Whoops, looks like something went wrong.', $response);
+        $this->assertContains('<div class="trace trace-as-html">', $response);
+    }
+
+    public function testStatusCode()
+    {
+        $handler = new ExceptionHandler(false, 'iso8859-1');
+
+        ob_start();
+        $handler->sendPhpResponse(new NotFoundHttpException('Foo'));
+        $response = ob_get_clean();
+
+        $this->assertContains('Sorry, the page you are looking for could not be found.', $response);
+
+        $expectedHeaders = array(
+            array('HTTP/1.0 404', true, null),
+            array('Content-Type: text/html; charset=iso8859-1', true, null),
+        );
+
+        $this->assertSame($expectedHeaders, testHeader());
+    }
+
+    public function testHeaders()
+    {
+        $handler = new ExceptionHandler(false, 'iso8859-1');
+
+        ob_start();
+        $handler->sendPhpResponse(new MethodNotAllowedHttpException(array('POST')));
+        $response = ob_get_clean();
+
+        $expectedHeaders = array(
+            array('HTTP/1.0 405', true, null),
+            array('Allow: POST', false, null),
+            array('Content-Type: text/html; charset=iso8859-1', true, null),
+        );
+
+        $this->assertSame($expectedHeaders, testHeader());
+    }
+
+    public function testNestedExceptions()
+    {
+        $handler = new ExceptionHandler(true);
+        ob_start();
+        $handler->sendPhpResponse(new \RuntimeException('Foo', 0, new \RuntimeException('Bar')));
+        $response = ob_get_clean();
+
+        $this->assertStringMatchesFormat('%A<p class="break-long-words trace-message">Foo</p>%A<p class="break-long-words trace-message">Bar</p>%A', $response);
+    }
+
+    public function testHandle()
+    {
+        $exception = new \Exception('foo');
+
+        $handler = $this->getMockBuilder('Symfony\Component\Debug\ExceptionHandler')->setMethods(array('sendPhpResponse'))->getMock();
+        $handler
+            ->expects($this->exactly(2))
+            ->method('sendPhpResponse');
+
+        $handler->handle($exception);
+
+        $handler->setHandler(function ($e) use ($exception) {
+            $this->assertSame($exception, $e);
+        });
+
+        $handler->handle($exception);
+    }
+
+    public function testHandleOutOfMemoryException()
+    {
+        $exception = new OutOfMemoryException('foo', 0, E_ERROR, __FILE__, __LINE__);
+
+        $handler = $this->getMockBuilder('Symfony\Component\Debug\ExceptionHandler')->setMethods(array('sendPhpResponse'))->getMock();
+        $handler
+            ->expects($this->once())
+            ->method('sendPhpResponse');
+
+        $handler->setHandler(function ($e) {
+            $this->fail('OutOfMemoryException should bypass the handler');
+        });
+
+        $handler->handle($exception);
+    }
+}

vendor/symfony/debug/Tests/FatalErrorHandler/ClassNotFoundFatalErrorHandlerTest.php

@@ -0,0 +1,176 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Debug\Tests\FatalErrorHandler;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Debug\Exception\FatalErrorException;
+use Symfony\Component\Debug\FatalErrorHandler\ClassNotFoundFatalErrorHandler;
+use Symfony\Component\Debug\DebugClassLoader;
+use Composer\Autoload\ClassLoader as ComposerClassLoader;
+
+class ClassNotFoundFatalErrorHandlerTest extends TestCase
+{
+    public static function setUpBeforeClass()
+    {
+        foreach (spl_autoload_functions() as $function) {
+            if (!is_array($function)) {
+                continue;
+            }
+
+            // get class loaders wrapped by DebugClassLoader
+            if ($function[0] instanceof DebugClassLoader) {
+                $function = $function[0]->getClassLoader();
+            }
+
+            if ($function[0] instanceof ComposerClassLoader) {
+                $function[0]->add('Symfony_Component_Debug_Tests_Fixtures', dirname(dirname(dirname(dirname(dirname(__DIR__))))));
+                break;
+            }
+        }
+    }
+
+    /**
+     * @dataProvider provideClassNotFoundData
+     */
+    public function testHandleClassNotFound($error, $translatedMessage, $autoloader = null)
+    {
+        if ($autoloader) {
+            // Unregister all autoloaders to ensure the custom provided
+            // autoloader is the only one to be used during the test run.
+            $autoloaders = spl_autoload_functions();
+            array_map('spl_autoload_unregister', $autoloaders);
+            spl_autoload_register($autoloader);
+        }
+
+        $handler = new ClassNotFoundFatalErrorHandler();
+
+        $exception = $handler->handleError($error, new FatalErrorException('', 0, $error['type'], $error['file'], $error['line']));
+
+        if ($autoloader) {
+            spl_autoload_unregister($autoloader);
+            array_map('spl_autoload_register', $autoloaders);
+        }
+
+        $this->assertInstanceOf('Symfony\Component\Debug\Exception\ClassNotFoundException', $exception);
+        $this->assertSame($translatedMessage, $exception->getMessage());
+        $this->assertSame($error['type'], $exception->getSeverity());
+        $this->assertSame($error['file'], $exception->getFile());
+        $this->assertSame($error['line'], $exception->getLine());
+    }
+
+    public function provideClassNotFoundData()
+    {
+        $autoloader = new ComposerClassLoader();
+        $autoloader->add('Symfony\Component\Debug\Exception\\', realpath(__DIR__.'/../../Exception'));
+
+        $debugClassLoader = new DebugClassLoader(array($autoloader, 'loadClass'));
+
+        return array(
+            array(
+                array(
+                    '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?",
+            ),
+            array(
+                array(
+                    '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?",
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class \'UndefinedFunctionException\' not found',
+                ),
+                "Attempted to load class \"UndefinedFunctionException\" from the global namespace.\nDid you forget a \"use\" statement for \"Symfony\Component\Debug\Exception\UndefinedFunctionException\"?",
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class \'PEARClass\' not found',
+                ),
+                "Attempted to load class \"PEARClass\" from the global namespace.\nDid you forget a \"use\" statement for \"Symfony_Component_Debug_Tests_Fixtures_PEARClass\"?",
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class \'Foo\\Bar\\UndefinedFunctionException\' not found',
+                ),
+                "Attempted to load class \"UndefinedFunctionException\" from namespace \"Foo\Bar\".\nDid you forget a \"use\" statement for \"Symfony\Component\Debug\Exception\UndefinedFunctionException\"?",
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class \'Foo\\Bar\\UndefinedFunctionException\' not found',
+                ),
+                "Attempted to load class \"UndefinedFunctionException\" from namespace \"Foo\Bar\".\nDid you forget a \"use\" statement for \"Symfony\Component\Debug\Exception\UndefinedFunctionException\"?",
+                array($autoloader, 'loadClass'),
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class \'Foo\\Bar\\UndefinedFunctionException\' not found',
+                ),
+                "Attempted to load class \"UndefinedFunctionException\" from namespace \"Foo\Bar\".\nDid you forget a \"use\" statement for \"Symfony\Component\Debug\Exception\UndefinedFunctionException\"?",
+                array($debugClassLoader, 'loadClass'),
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Class \'Foo\\Bar\\UndefinedFunctionException\' not found',
+                ),
+                "Attempted to load class \"UndefinedFunctionException\" from namespace \"Foo\\Bar\".\nDid you forget a \"use\" statement for another namespace?",
+                function ($className) { /* do nothing here */ },
+            ),
+        );
+    }
+
+    public function testCannotRedeclareClass()
+    {
+        if (!file_exists(__DIR__.'/../FIXTURES2/REQUIREDTWICE.PHP')) {
+            $this->markTestSkipped('Can only be run on case insensitive filesystems');
+        }
+
+        require_once __DIR__.'/../FIXTURES2/REQUIREDTWICE.PHP';
+
+        $error = array(
+            'type' => 1,
+            'line' => 12,
+            'file' => 'foo.php',
+            'message' => 'Class \'Foo\\Bar\\RequiredTwice\' not found',
+        );
+
+        $handler = new ClassNotFoundFatalErrorHandler();
+        $exception = $handler->handleError($error, new FatalErrorException('', 0, $error['type'], $error['file'], $error['line']));
+
+        $this->assertInstanceOf('Symfony\Component\Debug\Exception\ClassNotFoundException', $exception);
+    }
+}

vendor/symfony/debug/Tests/FatalErrorHandler/UndefinedFunctionFatalErrorHandlerTest.php

@@ -0,0 +1,81 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Debug\Tests\FatalErrorHandler;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Debug\Exception\FatalErrorException;
+use Symfony\Component\Debug\FatalErrorHandler\UndefinedFunctionFatalErrorHandler;
+
+class UndefinedFunctionFatalErrorHandlerTest extends TestCase
+{
+    /**
+     * @dataProvider provideUndefinedFunctionData
+     */
+    public function testUndefinedFunction($error, $translatedMessage)
+    {
+        $handler = new UndefinedFunctionFatalErrorHandler();
+        $exception = $handler->handleError($error, new FatalErrorException('', 0, $error['type'], $error['file'], $error['line']));
+
+        $this->assertInstanceOf('Symfony\Component\Debug\Exception\UndefinedFunctionException', $exception);
+        // class names are case insensitive and PHP/HHVM do not return the same
+        $this->assertSame(strtolower($translatedMessage), strtolower($exception->getMessage()));
+        $this->assertSame($error['type'], $exception->getSeverity());
+        $this->assertSame($error['file'], $exception->getFile());
+        $this->assertSame($error['line'], $exception->getLine());
+    }
+
+    public function provideUndefinedFunctionData()
+    {
+        return array(
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Call to undefined function test_namespaced_function()',
+                ),
+                "Attempted to call function \"test_namespaced_function\" from the global namespace.\nDid you mean to call \"\\symfony\\component\\debug\\tests\\fatalerrorhandler\\test_namespaced_function\"?",
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Call to undefined function Foo\\Bar\\Baz\\test_namespaced_function()',
+                ),
+                "Attempted to call function \"test_namespaced_function\" from namespace \"Foo\\Bar\\Baz\".\nDid you mean to call \"\\symfony\\component\\debug\\tests\\fatalerrorhandler\\test_namespaced_function\"?",
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Call to undefined function foo()',
+                ),
+                'Attempted to call function "foo" from the global namespace.',
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Call to undefined function Foo\\Bar\\Baz\\foo()',
+                ),
+                'Attempted to call function "foo" from namespace "Foo\Bar\Baz".',
+            ),
+        );
+    }
+}
+
+function test_namespaced_function()
+{
+}

vendor/symfony/debug/Tests/FatalErrorHandler/UndefinedMethodFatalErrorHandlerTest.php

@@ -0,0 +1,76 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Debug\Tests\FatalErrorHandler;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Debug\Exception\FatalErrorException;
+use Symfony\Component\Debug\FatalErrorHandler\UndefinedMethodFatalErrorHandler;
+
+class UndefinedMethodFatalErrorHandlerTest extends TestCase
+{
+    /**
+     * @dataProvider provideUndefinedMethodData
+     */
+    public function testUndefinedMethod($error, $translatedMessage)
+    {
+        $handler = new UndefinedMethodFatalErrorHandler();
+        $exception = $handler->handleError($error, new FatalErrorException('', 0, $error['type'], $error['file'], $error['line']));
+
+        $this->assertInstanceOf('Symfony\Component\Debug\Exception\UndefinedMethodException', $exception);
+        $this->assertSame($translatedMessage, $exception->getMessage());
+        $this->assertSame($error['type'], $exception->getSeverity());
+        $this->assertSame($error['file'], $exception->getFile());
+        $this->assertSame($error['line'], $exception->getLine());
+    }
+
+    public function provideUndefinedMethodData()
+    {
+        return array(
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Call to undefined method SplObjectStorage::what()',
+                ),
+                'Attempted to call an undefined method named "what" of class "SplObjectStorage".',
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Call to undefined method SplObjectStorage::walid()',
+                ),
+                "Attempted to call an undefined method named \"walid\" of class \"SplObjectStorage\".\nDid you mean to call \"valid\"?",
+            ),
+            array(
+                array(
+                    'type' => 1,
+                    'line' => 12,
+                    'file' => 'foo.php',
+                    'message' => 'Call to undefined method SplObjectStorage::offsetFet()',
+                ),
+                "Attempted to call an undefined method named \"offsetFet\" of class \"SplObjectStorage\".\nDid you mean to call e.g. \"offsetGet\", \"offsetSet\" or \"offsetUnset\"?",
+            ),
+            array(
+                array(
+                  'type' => 1,
+                  'message' => 'Call to undefined method class@anonymous::test()',
+                  'file' => '/home/possum/work/symfony/test.php',
+                  'line' => 11,
+                ),
+                'Attempted to call an undefined method named "test" of class "class@anonymous".',
+            ),
+        );
+    }
+}

vendor/symfony/debug/Tests/Fixtures/AnnotatedClass.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class AnnotatedClass
+{
+    /**
+     * @deprecated since version 3.4.
+     */
+    public function deprecatedMethod()
+    {
+    }
+}

vendor/symfony/debug/Tests/Fixtures/ClassAlias.php

@@ -0,0 +1,3 @@
+<?php
+
+class_alias('Symfony\Component\Debug\Tests\Fixtures\NotPSR0bis', 'Symfony\Component\Debug\Tests\Fixtures\ClassAlias');

vendor/symfony/debug/Tests/Fixtures/DeprecatedClass.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @deprecated but this is a test
+ *             deprecation notice
+ * @foobar
+ */
+class DeprecatedClass
+{
+}

vendor/symfony/debug/Tests/Fixtures/DeprecatedInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @deprecated but this is a test
+ *             deprecation notice
+ * @foobar
+ */
+interface DeprecatedInterface
+{
+}

vendor/symfony/debug/Tests/Fixtures/ExtendedFinalMethod.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class ExtendedFinalMethod extends FinalMethod
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function finalMethod()
+    {
+    }
+
+    public function anotherMethod()
+    {
+    }
+}

vendor/symfony/debug/Tests/Fixtures/FinalClass.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @final since version 3.3.
+ */
+class FinalClass
+{
+}

vendor/symfony/debug/Tests/Fixtures/FinalMethod.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class FinalMethod
+{
+    /**
+     * @final since version 3.3.
+     */
+    public function finalMethod()
+    {
+    }
+
+    public function anotherMethod()
+    {
+    }
+}

vendor/symfony/debug/Tests/Fixtures/InternalClass.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @internal since version 3.4.
+ */
+class InternalClass
+{
+    use InternalTrait2;
+
+    public function usedInInternalClass()
+    {
+    }
+}

vendor/symfony/debug/Tests/Fixtures/InternalInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @internal
+ */
+interface InternalInterface
+{
+}

vendor/symfony/debug/Tests/Fixtures/InternalTrait.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @internal
+ */
+trait InternalTrait
+{
+}

vendor/symfony/debug/Tests/Fixtures/InternalTrait2.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+/**
+ * @internal
+ */
+trait InternalTrait2
+{
+    /**
+     * @internal since version 3.4
+     */
+    public function internalMethod()
+    {
+    }
+
+    /**
+     * @internal but should not trigger a deprecation
+     */
+    public function usedInInternalClass()
+    {
+    }
+}

vendor/symfony/debug/Tests/Fixtures/NonDeprecatedInterface.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+interface NonDeprecatedInterface extends DeprecatedInterface
+{
+}

vendor/symfony/debug/Tests/Fixtures/PEARClass.php

@@ -0,0 +1,5 @@
+<?php
+
+class Symfony_Component_Debug_Tests_Fixtures_PEARClass
+{
+}

vendor/symfony/debug/Tests/Fixtures/Throwing.php

@@ -0,0 +1,3 @@
+<?php
+
+throw new \Exception('boo');

vendor/symfony/debug/Tests/Fixtures/ToStringThrower.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class ToStringThrower
+{
+    private $exception;
+
+    public function __construct(\Exception $e)
+    {
+        $this->exception = $e;
+    }
+
+    public function __toString()
+    {
+        try {
+            throw $this->exception;
+        } catch (\Exception $e) {
+            // Using user_error() here is on purpose so we do not forget
+            // that this alias also should work alongside with trigger_error().
+            return user_error($e, E_USER_ERROR);
+        }
+    }
+}

vendor/symfony/debug/Tests/Fixtures/casemismatch.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class CaseMismatch
+{
+}

vendor/symfony/debug/Tests/Fixtures/notPsr0Bis.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class NotPSR0bis
+{
+}

vendor/symfony/debug/Tests/Fixtures/psr4/Psr4CaseMismatch.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class PSR4CaseMismatch
+{
+}

vendor/symfony/debug/Tests/Fixtures/reallyNotPsr0.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+class NotPSR0
+{
+}

vendor/symfony/debug/Tests/Fixtures2/RequiredTwice.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures2;
+
+class RequiredTwice
+{
+}

vendor/symfony/debug/Tests/HeaderMock.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Debug;
+
+function headers_sent()
+{
+    return false;
+}
+
+function header($str, $replace = true, $status = null)
+{
+    Tests\testHeader($str, $replace, $status);
+}
+
+namespace Symfony\Component\Debug\Tests;
+
+function testHeader()
+{
+    static $headers = array();
+
+    if (!$h = func_get_args()) {
+        $h = $headers;
+        $headers = array();
+
+        return $h;
+    }
+
+    $headers[] = func_get_args();
+}

vendor/symfony/debug/Tests/MockExceptionHandler.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Debug\Tests;
+
+use Symfony\Component\Debug\ExceptionHandler;
+
+class MockExceptionHandler extends ExceptionHandler
+{
+    public $e;
+
+    public function handle(\Exception $e)
+    {
+        $this->e = $e;
+    }
+}

vendor/symfony/debug/Tests/phpt/debug_class_loader.phpt

@@ -0,0 +1,26 @@
+--TEST--
+Test DebugClassLoader with previously loaded parents
+--FILE--
+<?php
+
+namespace Symfony\Component\Debug\Tests\Fixtures;
+
+use Symfony\Component\Debug\DebugClassLoader;
+
+$vendor = __DIR__;
+while (!file_exists($vendor.'/vendor')) {
+    $vendor = dirname($vendor);
+}
+require $vendor.'/vendor/autoload.php';
+
+class_exists(FinalMethod::class);
+
+set_error_handler(function ($type, $msg) { echo $msg, "\n"; });
+
+DebugClassLoader::enable();
+
+class_exists(ExtendedFinalMethod::class);
+
+?>
+--EXPECTF--
+The "Symfony\Component\Debug\Tests\Fixtures\FinalMethod::finalMethod()" method is considered final since version 3.3. It may change without further notice as of its next major version. You should not extend it from "Symfony\Component\Debug\Tests\Fixtures\ExtendedFinalMethod".

vendor/symfony/debug/Tests/phpt/exception_rethrown.phpt

@@ -0,0 +1,35 @@
+--TEST--
+Test rethrowing in custom exception handler
+--FILE--
+<?php
+
+namespace Symfony\Component\Debug;
+
+$vendor = __DIR__;
+while (!file_exists($vendor.'/vendor')) {
+    $vendor = dirname($vendor);
+}
+require $vendor.'/vendor/autoload.php';
+
+if (true) {
+    class TestLogger extends \Psr\Log\AbstractLogger
+    {
+        public function log($level, $message, array $context = array())
+        {
+            echo $message, "\n";
+        }
+    }
+}
+
+set_exception_handler(function ($e) { echo 123; throw $e; });
+ErrorHandler::register()->setDefaultLogger(new TestLogger());
+ini_set('display_errors', 1);
+
+throw new \Exception('foo');
+?>
+--EXPECTF--
+Uncaught Exception: foo
+123
+Fatal error: Uncaught %s:25
+Stack trace:
+%a

vendor/symfony/debug/Tests/phpt/fatal_with_nested_handlers.phpt

@@ -0,0 +1,42 @@
+--TEST--
+Test catching fatal errors when handlers are nested
+--FILE--
+<?php
+
+namespace Symfony\Component\Debug;
+
+$vendor = __DIR__;
+while (!file_exists($vendor.'/vendor')) {
+    $vendor = dirname($vendor);
+}
+require $vendor.'/vendor/autoload.php';
+
+Debug::enable();
+ini_set('display_errors', 0);
+
+$eHandler = set_error_handler('var_dump');
+$xHandler = set_exception_handler('var_dump');
+
+var_dump(array(
+    $eHandler[0] === $xHandler[0] ? 'Error and exception handlers do match' : 'Error and exception handlers are different',
+));
+
+$eHandler[0]->setExceptionHandler('print_r');
+
+if (true) {
+    class Broken implements \Serializable
+    {
+    }
+}
+
+?>
+--EXPECTF--
+array(1) {
+  [0]=>
+  string(37) "Error and exception handlers do match"
+}
+object(Symfony\Component\Debug\Exception\FatalErrorException)#%d (%d) {
+  ["message":protected]=>
+  string(199) "Error: Class Symfony\Component\Debug\Broken contains 2 abstract methods and must therefore be declared abstract or implement the remaining methods (Serializable::serialize, Serializable::unserialize)"
+%a
+}