Failing test cases are not a problem anymore.

@param PHPUnit_Framework_TestCase $test
345719
public function force(PHPUnit_Framework_TestCase $test)
    {
        if (!$test->hasFailed()) {
            return;
        }
        $testReflection = new ReflectionClass('PHPUnit_Framework_TestCase');
        $resultReflection = new ReflectionClass('PHPUnit_Framework_TestResult');

        $result = $this->getPropertyValue($testReflection, 'result', $test);
        $this
            ->forcePropertyValue($resultReflection, 'errors', array(), $result)
            ->forcePropertyValue($resultReflection, 'failures', array(), $result)
            ->forcePropertyValue($resultReflection, 'risky', array(), $result)
            ->forcePropertyValue($testReflection, 'status', PHPUnit_Runner_BaseTestRunner::STATUS_PASSED, $test)
            ->forcePropertyValue($testReflection, 'statusMessage', '', $test);
    }
205142
public function addFailure(Test $test)
    {
        $this->output->updateTable($test->pos->x, $test->pos->y, Graphite::RED);
        $this->failures[] = $test;
    }
1268508
public static function clean()
    {
        Console::printLine('Start Clean PHPUnit Report', 'information');
        $removeList = array(
            self::getBasePath()
        );
        $result = FileSystem::remove($removeList);
        if ($result) {
            Console::printLine('Clean PHPUnit Report Finished', 'success');
            return true;
        }
        Console::printLine('Clean PHPUnit Report Error', 'error');
        return false;
    }
24771
public function addWarning(Test $test, Warning $warning, float $time): void
    {
        $this->writeCase(
            self::STATUS_WARNING,
            $time,
            $this->getStackTrace($warning),
            TestFailure::exceptionToString($warning),
            $test
        );

        $this->currentTestPass = false;
    }
705902
public function addWarning(Test $test, Warning $e, float $time): void
    {
        $this->doAddFault($test, $e, $time, 'warning');
        $this->testSuiteFailures[$this->testSuiteLevel]++;
    }
6750
public function _before(TestInterface $test)
    {
        if (!extension_loaded('apc') && !extension_loaded('apcu')) {
            throw new ModuleException(
                __CLASS__,
                'The APC(u) extension not loaded.'
            );
        }

        if (!ini_get('apc.enabled') || (PHP_SAPI === 'cli' && !ini_get('apc.enable_cli'))) {
            throw new ModuleException(
                __CLASS__,
                'The "apc.enable_cli" parameter must be set to "On".'
            );
        }
    }
945997
public function _after(TestInterface $test)
    {
        $this->debugSection('ComposerProject', 'Deleting temporary directory...');

        $this->filesystem->deleteDir($this->tmpProjectDir);

        $this->debugSection('ComposerProject', 'Deleted temporary directory');
    }
464597
public function deleteContent( core_kernel_classes_Resource $test)
    {
        /** @var \core_kernel_classes_Literal $directoryId */
        $directoryId = $test->getOnePropertyValue($this->getProperty(TestService::PROPERTY_TEST_CONTENT));
        if(is_null($directoryId)){
            throw new \common_exception_FileSystemError(__('Unknown test directory'));
        }

        $directory = \tao_models_classes_service_FileStorage::singleton()->getDirectoryById($directoryId->literal);
        $directory->deleteSelf();

		$test->removePropertyValues($this->getProperty(TestService::PROPERTY_TEST_CONTENT));
    }
813505
public function _before(TestInterface $test)
    {
        /** @noinspection PhpIncludeInspection */
        $application = require $this->bootstrapFile;
        if (!$application instanceof Injectable) {
            throw new ModuleException(__CLASS__, 'Bootstrap must return \Phalcon\Di\Injectable object');
        }

        $this->di = $application->getDI();

        Di::reset();
        Di::setDefault($this->di);

        if ($this->di->has('session')) {
            // Destroy existing sessions of previous tests
            $this->di['session'] = $this->di->get($this->config['session']);
        }

        if ($this->di->has('cookies')) {
            $this->di['cookies']->useEncryption(false);
        }

        if ($this->config['cleanup'] && $this->di->has('db')) {
            if ($this->config['savepoints']) {
                $this->di['db']->setNestedTransactionsWithSavepoints(true);
            }
            $this->di['db']->begin();
            $this->debugSection('Database', 'Transaction started');
        }

        // localize
        $bootstrap = $this->bootstrapFile;
        $this->client->setApplication(function () use ($bootstrap) {
            $currentDi = Di::getDefault();
            /** @noinspection PhpIncludeInspection */
            $application = require $bootstrap;
            $di = $application->getDI();
            if ($currentDi->has('db')) {
                $di['db'] = $currentDi['db'];
            }
            if ($currentDi->has('session')) {
                $di['session'] = $currentDi['session'];
            }
            if ($di->has('cookies')) {
                $di['cookies']->useEncryption(false);
            }
            return $application;
        });
    }
1013013
public function addError(Test $test)
    {
        $this->output->updateTable($test->pos->x, $test->pos->y, Graphite::YELLOW);
        $this->errors[] = $test;
    }
473155
public function isEnqueued($test)
    {
        return
            $test->state == Constants::STATE_QUEUED
            &&
            QueueModel::where('test_id', $test->id)->first();
    }
411005
public function _before(TestInterface $test)
    {
        $this->createTmpProjectDir();
        $this->copyProjectRootToTmpProjectDir();

        $this->amInTmpProjectDir();

        $this->configComposerRepositoryPaths($this->_getConfig('repositoryPaths'));
        $this->runComposerInstall();
    }
1232869
public function beforeExample(ScenarioTested $event)
    {
        $this->currentTestcase = $this->currentTestsuite->addChild('testcase');
        $this->currentTestcase->addAttribute('name', $this->currentOutlineTitle . ' Line #' . $event->getScenario()->getLine());

        $this->testcaseTimer->start();
    }
74516
private function loadFixtures($test)
    {
        $this->debugSection('Fixtures', 'Loading fixtures');
        if (empty($this->loadedFixtures)
            && method_exists($test, $this->_getConfig('fixturesMethod'))
        ) {
            $connectionWatcher = new Yii2Connector\ConnectionWatcher();
            $connectionWatcher->start();
            $this->haveFixtures(call_user_func([$test, $this->_getConfig('fixturesMethod')]));
            $connectionWatcher->stop();
            $connectionWatcher->closeAll();
        }
        $this->debugSection('Fixtures', 'Done');
    }
263341
public function _after(TestInterface $test)
    {
        if ($this->sessionStatus() === PHP_SESSION_ACTIVE) {
            $this->sessionDestroy();
        }

        if (isset($this->client) && $this->client instanceof Connector) {
            $this->client->reset();
            
            if (isset($this->baseRequest)) {
                $this->baseRequest = $this->client->getBaseRequest();
            }
            
            if (isset($this->baseResponse)) {
                $this->baseResponse = $this->client->getBaseResponse();
            }
        }

        parent::_after($test);
    }
944490
protected function isFailedSuite(array $tests)
    {
        $failed = false;

        foreach ($tests as $test) {
            if ($test['exception']) {
                $failed = true;
                break;
            }
        }

        return $failed;
    }
1219879
public function _after(TestCase $test)
    {
        $_SESSION = array();
        $_GET = array();
        $_POST = array();
        $_COOKIE = array();
        parent::_after($test);
    }