Enhanced PHP File Manager

⬆️ Go Up (..)

📊 Server Information

Server:

LiteSpeed

System:

Linux 4.18.0-553.40.1.lve.el8.x86_64

PHP Version:

8.2.27

User:

u506365997

Directory:

/home/u506365997/domains/creativeink.in/creativeink.in/vendor/filp/whoops/tests/Whoops

Free Space:

2.91 TB

🔧 Quick Actions

✏️ Editing: RunTest.php

<?php
/**
 * Whoops - php errors for cool kids
 * @author Filipe Dobreira <http://github.com/filp>
 */

namespace Whoops;

use ArrayObject;
use Exception;
use InvalidArgumentException;
use Mockery as m;
use RuntimeException;
use Whoops\Handler\Handler;
use Whoops\Handler\HandlerInterface;
use Whoops\Handler\PrettyPageHandler;
use Whoops\Exception\Frame;
use Whoops\Util\SystemFacade;

class RunTest extends TestCase
{
    public function testImplementsRunInterface()
    {
        $this->assertNotFalse(class_implements('Whoops\\Run', 'Whoops\\RunInterface'));
    }

public function testConstantsAreAccessibleFromTheClass()
    {
        $this->assertEquals(RunInterface::ERROR_HANDLER, Run::ERROR_HANDLER);
        $this->assertEquals(RunInterface::EXCEPTION_HANDLER, Run::EXCEPTION_HANDLER);
        $this->assertEquals(RunInterface::SHUTDOWN_HANDLER, Run::SHUTDOWN_HANDLER);
    }

/**
     * @param  string    $message
     * @return Exception
     */
    protected function getException($message = "")
    {
        // HHVM does not support mocking exceptions
        // Since we do not use any additional features of Mockery for exceptions,
        // we can just use native Exceptions instead.
        return new \Exception($message);
    }

/**
     * @return Handler
     */
    protected function getHandler()
    {
        return m::mock('Whoops\\Handler\\Handler')
            ->shouldReceive('setRun')
                ->andReturn(null)
            ->mock()

->shouldReceive('setInspector')
                ->andReturn(null)
            ->mock()

->shouldReceive('setException')
                ->andReturn(null)
            ->mock();
    }

/**
     * @covers Whoops\Run::clearHandlers
     */
    public function testClearHandlers()
    {
        $run = $this->getRunInstance();
        $run->clearHandlers();

$handlers = $run->getHandlers();

$this->assertEmpty($handlers);
    }

/**
     * @covers Whoops\Run::pushHandler
     */
    public function testPushHandler()
    {
        $run = $this->getRunInstance();
        $run->clearHandlers();

$handlerOne = $this->getHandler();
        $handlerTwo = $this->getHandler();

$run->pushHandler($handlerOne);
        $run->pushHandler($handlerTwo);

$handlers = $run->getHandlers();

$this->assertCount(2, $handlers);
        $this->assertContains($handlerOne, $handlers);
        $this->assertContains($handlerTwo, $handlers);
    }

/**
     * @covers Whoops\Run::pushHandler
     */
    public function testPushInvalidHandler()
    {
        $run = $this->getRunInstance();

$this->expectExceptionOfType('InvalidArgumentException');

$run->pushHandler('actually turnip');
    }

/**
     * @covers Whoops\Run::pushHandler
     */
    public function testPushClosureBecomesHandler()
    {
        $run = $this->getRunInstance();
        $run->pushHandler(function () {});
        $this->assertInstanceOf('Whoops\\Handler\\CallbackHandler', $run->popHandler());
    }

/**
     * @covers Whoops\Run::popHandler
     * @covers Whoops\Run::getHandlers
     */
    public function testPopHandler()
    {
        $run = $this->getRunInstance();

$handlerOne   = $this->getHandler();
        $handlerTwo   = $this->getHandler();
        $handlerThree = $this->getHandler();

$run->pushHandler($handlerOne);
        $run->pushHandler($handlerTwo);
        $run->pushHandler($handlerThree);

$this->assertSame($handlerThree, $run->popHandler());
        $this->assertSame($handlerTwo, $run->popHandler());
        $this->assertSame($handlerOne, $run->popHandler());

// Should return null if there's nothing else in
        // the stack
        $this->assertNull($run->popHandler());

// Should be empty since we popped everything off
        // the stack:
        $this->assertEmpty($run->getHandlers());
    }

/**
     * @covers Whoops\Run::removeFirstHandler
     * @covers Whoops\Run::removeLastHandler
     * @covers Whoops\Run::getHandlers
     */
    public function testRemoveHandler()
    {
        $run = $this->getRunInstance();

$handlerOne   = $this->getHandler();
        $handlerTwo   = $this->getHandler();
        $handlerThree = $this->getHandler();

$run->pushHandler($handlerOne);
        $run->pushHandler($handlerTwo);
        $run->pushHandler($handlerThree);

$run->removeLastHandler();
        $this->assertSame($handlerTwo, $run->getHandlers()[0]);
        $run->removeFirstHandler();
        $this->assertSame($handlerTwo, $run->getHandlers()[0]);
        $this->assertCount(1, $run->getHandlers());
    }

/**
     * @covers Whoops\Run::register
     */
    public function testRegisterHandler()
    {
        // It is impossible to test the Run::register method using phpunit,
        // as given how every test is always inside a giant try/catch block,
        // any thrown exception will never hit a global exception handler.
        // On the other hand, there is not much need in testing
        // a call to a native PHP function.
        $this->assertTrue(true);
    }

/**
     * @covers Whoops\Run::unregister
     */
    public function testUnregisterHandler()
    {
        $run = $this->getRunInstance();
        $run->register();

$handler = $this->getHandler();
        $run->pushHandler($handler);

$run->unregister();

$this->expectExceptionOfType('Exception');

throw $this->getException("I'm not supposed to be caught!");
    }

/**
     * @covers Whoops\Run::pushHandler
     * @covers Whoops\Run::getHandlers
     */
    public function testHandlerHoldsOrder()
    {
        $run = $this->getRunInstance();

$handlerOne   = $this->getHandler();
        $handlerTwo   = $this->getHandler();
        $handlerThree = $this->getHandler();
        $handlerFour  = $this->getHandler();

$run->pushHandler($handlerOne);
        $run->prependHandler($handlerTwo);
        $run->appendHandler($handlerThree);
        $run->appendHandler($handlerFour);

$handlers = $run->getHandlers();

$this->assertSame($handlers[0], $handlerFour);
        $this->assertSame($handlers[1], $handlerThree);
        $this->assertSame($handlers[2], $handlerOne);
        $this->assertSame($handlers[3], $handlerTwo);
    }

/**
     * @todo possibly split this up a bit and move
     *       some of this test to Handler unit tests?
     * @covers Whoops\Run::handleException
     */
    public function testHandlersGonnaHandle()
    {
        $run       = $this->getRunInstance();
        $exception = $this->getException();
        $order     = new ArrayObject();

$handlerOne   = $this->getHandler();
        $handlerTwo   = $this->getHandler();
        $handlerThree = $this->getHandler();

$handlerOne->shouldReceive('handle')
            ->andReturnUsing(function () use ($order) { $order[] = 1; });
        $handlerTwo->shouldReceive('handle')
            ->andReturnUsing(function () use ($order) { $order[] = 2; });
        $handlerThree->shouldReceive('handle')
            ->andReturnUsing(function () use ($order) { $order[] = 3; });

$run->pushHandler($handlerOne);
        $run->pushHandler($handlerTwo);
        $run->pushHandler($handlerThree);

// Get an exception to be handled, and verify that the handlers
        // are given the handler, and in the inverse order they were
        // registered.
        $run->handleException($exception);
        $this->assertEquals((array) $order, [3, 2, 1]);
    }

/**
     * @covers Whoops\Run::handleException
     */
    public function testLastHandler()
    {
        $run = $this->getRunInstance();

$handlerOne = $this->getHandler();
        $handlerTwo = $this->getHandler();
        $handlerThree = $this->getHandler();
        $handlerFour = $this->getHandler();

$run->pushHandler($handlerOne);
        $run->prependHandler($handlerTwo);
        $run->appendHandler($handlerThree);
        $run->appendHandler($handlerFour);

$test = $this;
        $handlerFour
            ->shouldReceive('handle')
            ->andReturnUsing(function () use ($test) {
                $test->fail('$handlerFour should not be called');
            });

$handlerThree
            ->shouldReceive('handle')
            ->andReturn(Handler::LAST_HANDLER);

$twoRan = false;

$handlerOne
            ->shouldReceive('handle')
            ->andReturnUsing(function () use ($test, &$twoRan) {
                $test->assertTrue($twoRan);
            });

$handlerTwo
            ->shouldReceive('handle')
            ->andReturnUsing(function () use (&$twoRan) {
                $twoRan = true;
            });

$run->handleException($this->getException());

// Reached the end without errors
        $this->assertTrue(true);
    }

/**
     * Test error suppression using @ operator.
     */
    public function testErrorSuppression()
    {
        $run = $this->getRunInstance();
        $run->register();

$handler = $this->getHandler();
        $run->pushHandler($handler);

$test = $this;
        $handler
            ->shouldReceive('handle')
            ->andReturnUsing(function () use ($test) {
                $test->fail('$handler should not be called, error not suppressed');
            });

@trigger_error("Test error suppression");

// Reached the end without errors
        $this->assertTrue(true);
    }

public function testErrorCatching()
    {
        $run = $this->getRunInstance();
        $run->register();

$handler = $this->getHandler();
        $run->pushHandler($handler);

$test = $this;
        $handler
            ->shouldReceive('handle')
            ->andReturnUsing(function () use ($test) {
                $test->fail('$handler should not be called error should be caught');
            });

try {
            trigger_error('foo', E_USER_NOTICE);
            $this->fail('Should not continue after error thrown');
        } catch (\ErrorException $e) {
            // Do nothing
            $this->assertTrue(true);
            return;
        }
        $this->fail('Should not continue here, should have been caught.');
    }

/**
     * Test to make sure that error_reporting is respected.
     */
    public function testErrorReporting()
    {
        $run = $this->getRunInstance();
        $run->register();

$handler = $this->getHandler();
        $run->pushHandler($handler);

$test = $this;
        $handler
            ->shouldReceive('handle')
            ->andReturnUsing(function () use ($test) {
                $test->fail('$handler should not be called, error_reporting not respected');
            });

$oldLevel = error_reporting(E_ALL ^ E_USER_NOTICE);
        trigger_error("Test error reporting", E_USER_NOTICE);
        error_reporting($oldLevel);

// Reached the end without errors
        $this->assertTrue(true);
    }

/**
     * @covers Whoops\Run::silenceErrorsInPaths
     */
    public function testSilenceErrorsInPaths()
    {
        $run = $this->getRunInstance();
        $run->register();

$handler = $this->getHandler();
        $run->pushHandler($handler);

$test = $this;
        $handler
            ->shouldReceive('handle')
            ->andReturnUsing(function () use ($test) {
                $test->fail('$handler should not be called, silenceErrorsInPaths not respected');
            });

$run->silenceErrorsInPaths('@^'.preg_quote(__FILE__, '@').'$@', E_USER_NOTICE);
        trigger_error('Test', E_USER_NOTICE);
        $this->assertTrue(true);
    }

/**
     * @covers Whoops\Run::handleError
     * @requires PHP < 8
     */
    public function testGetSilencedError()
    {
        $run = $this->getRunInstance();
        $run->register();

$handler = $this->getHandler();
        $run->pushHandler($handler);

@strpos();

$error = error_get_last();

$this->assertTrue($error && strpos($error['message'], 'strpos()') !== false);
    }

/**
     * @covers Whoops\Run::handleError
     * @see https://github.com/filp/whoops/issues/267
     */
    public function testErrorWrappedInException()
    {
        try {
            $run = $this->getRunInstance();
            $run->handleError(E_WARNING, 'my message', 'my file', 99);
            $this->fail("missing expected exception");
        } catch (\ErrorException $e) {
            $this->assertSame(E_WARNING, $e->getSeverity());
            $this->assertSame(E_WARNING, $e->getCode(), "For BC reasons getCode() should match getSeverity()");
            $this->assertSame('my message', $e->getMessage());
            $this->assertSame('my file', $e->getFile());
            $this->assertSame(99, $e->getLine());
        }
    }

/**
     * @covers Whoops\Run::handleException
     * @covers Whoops\Run::writeToOutput
     */
    public function testOutputIsSent()
    {
        $run = $this->getRunInstance();
        $run->pushHandler(function () {
            echo "hello there";
        });

ob_start();
        $run->handleException(new RuntimeException());
        $this->assertEquals("hello there", ob_get_clean());
    }

/**
     * @covers Whoops\Run::handleException
     * @covers Whoops\Run::writeToOutput
     */
    public function testOutputIsNotSent()
    {
        $run = $this->getRunInstance();
        $run->writeToOutput(false);
        $run->pushHandler(function () {
            echo "hello there";
        });

ob_start();
        $this->assertEquals("hello there", $run->handleException(new RuntimeException()));
        $this->assertEquals("", ob_get_clean());
    }

/**
     * @covers Whoops\Run::sendHttpCode
     */
    public function testSendHttpCode()
    {
        $run = $this->getRunInstance();
        $run->sendHttpCode(true);
        $this->assertEquals(500, $run->sendHttpCode());
    }

/**
     * @covers Whoops\Run::sendHttpCode
     */
    public function testSendHttpCodeNullCode()
    {
        $run = $this->getRunInstance();
        $this->assertEquals(false, $run->sendHttpCode(null));
    }

/**
     * @covers Whoops\Run::sendHttpCode
     */
    public function testSendHttpCodeWrongCode()
    {
        $this->expectExceptionOfType('InvalidArgumentException');

$this->getRunInstance()->sendHttpCode(1337);
    }

/**
     * @covers Whoops\Run::sendHttpCode
     */
    public function testSendExitCode()
    {
        $run = $this->getRunInstance();
        $run->sendExitCode(42);
        $this->assertEquals(42, $run->sendExitCode());
    }

/**
     * @covers Whoops\Run::sendExitCode
     */
    public function testSendExitCodeDefaultCode()
    {
        $run = $this->getRunInstance();
        $this->assertEquals(1, $run->sendExitCode());
    }

/**
     * @covers Whoops\Run::sendExitCode
     */
    public function testSendExitCodeWrongCode()
    {
        $this->expectExceptionOfType('InvalidArgumentException');

$this->getRunInstance()->sendExitCode(255);
    }

/**
     * @covers Whoops\Run::addFrameFilter
     * @covers Whoops\Run::getFrameFilters
     */
    public function testAddFrameFilter()
    {
        $run = $this->getRunInstance();

$filterCallbackOne = function(Frame $frame) {};
        $filterCallbackTwo = function(Frame $frame) {};

$run
            ->addFrameFilter($filterCallbackOne)
            ->addFrameFilter($filterCallbackTwo);

$frameFilters = $run->getFrameFilters();

$this->assertCount(2, $frameFilters);
        $this->assertContains($filterCallbackOne, $frameFilters);
        $this->assertContains($filterCallbackTwo, $frameFilters);
        $this->assertInstanceOf("Whoops\\RunInterface", $run);
    }

/**
     * @covers Whoops\Run::clearFrameFilters
     * @covers Whoops\Run::getFrameFilters
     */
    public function testClearFrameFilters()
    {
        $run = $this->getRunInstance();
        $run->addFrameFilter(function(Frame $frame) {});

$run = $run->clearFrameFilters();

$this->assertEmpty($run->getFrameFilters());
        $this->assertInstanceOf("Whoops\\RunInterface", $run);
    }

public function testShutdownHandlerDoesNotRunIfUnregistered()
    {
        $system = m::mock('Whoops\Util\SystemFacade');

$run = new Run($system);
        $run->writeToOutput(false);
        $run->allowQuit(false);

$fatalError = [
            'type'    => E_ERROR,
            'message' => 'Simulated fatal error for shutdown',
            'file'    => 'somefile.php',
            'line'    => 10,
        ];
        $system->shouldReceive('getLastError')->andReturn($fatalError)->byDefault();

$mockHandler = m::mock('Whoops\Handler\HandlerInterface');
        $mockHandler->shouldNotReceive('handle');
        $mockHandler->shouldNotReceive('setRun');
        $mockHandler->shouldNotReceive('setInspector');
        $mockHandler->shouldNotReceive('setException');
        $run->pushHandler($mockHandler);

$run->unregister();

ob_start();
        $run->handleShutdown();
        $output = ob_get_clean();

$this->assertEquals('', $output, "Output buffer should be empty.");
    }
}

❌ Cancel

🗂️ Enhanced PHP File Manager

📊 Server Information

🔧 Quick Actions

✏️ Editing: RunTest.php

📤 Upload File

📁 Create Folder

📄 Create File

✏️ Rename Item

🗑️ Delete Confirmation