chillerlan / php-traits

vendor/phpunit/phpunit/src/Framework/TestSuite.php

Indentation +981 added lines, -981 removed lines

@@ -25,985 +25,985 @@
  */
 class TestSuite implements Test, SelfDescribing, IteratorAggregate
 {
-    /**
-     * Last count of tests in this suite.
-     *
-     * @var int|null
-     */
-    private $cachedNumTests;
-
-    /**
-     * Enable or disable the backup and restoration of the $GLOBALS array.
-     *
-     * @var bool
-     */
-    protected $backupGlobals;
-
-    /**
-     * Enable or disable the backup and restoration of static attributes.
-     *
-     * @var bool
-     */
-    protected $backupStaticAttributes;
-
-    /**
-     * @var bool
-     */
-    private $beStrictAboutChangesToGlobalState;
-
-    /**
-     * @var bool
-     */
-    protected $runTestInSeparateProcess = false;
-
-    /**
-     * The name of the test suite.
-     *
-     * @var string
-     */
-    protected $name = '';
-
-    /**
-     * The test groups of the test suite.
-     *
-     * @var array
-     */
-    protected $groups = [];
-
-    /**
-     * The tests in the test suite.
-     *
-     * @var TestCase[]
-     */
-    protected $tests = [];
-
-    /**
-     * The number of tests in the test suite.
-     *
-     * @var int
-     */
-    protected $numTests = -1;
-
-    /**
-     * @var bool
-     */
-    protected $testCase = false;
-
-    /**
-     * @var array
-     */
-    protected $foundClasses = [];
-
-    /**
-     * @var Factory
-     */
-    private $iteratorFilter;
-
-    /**
-     * Constructs a new TestSuite:
-     *
-     *   - PHPUnit\Framework\TestSuite() constructs an empty TestSuite.
-     *
-     *   - PHPUnit\Framework\TestSuite(ReflectionClass) constructs a
-     *     TestSuite from the given class.
-     *
-     *   - PHPUnit\Framework\TestSuite(ReflectionClass, String)
-     *     constructs a TestSuite from the given class with the given
-     *     name.
-     *
-     *   - PHPUnit\Framework\TestSuite(String) either constructs a
-     *     TestSuite from the given class (if the passed string is the
-     *     name of an existing class) or constructs an empty TestSuite
-     *     with the given name.
-     *
-     * @param mixed  $theClass
-     * @param string $name
-     *
-     * @throws Exception
-     */
-    public function __construct($theClass = '', $name = '')
-    {
-        $argumentsValid = false;
-
-        if (\is_object($theClass) &&
-            $theClass instanceof ReflectionClass) {
-            $argumentsValid = true;
-        } elseif (\is_string($theClass) &&
-            $theClass !== '' &&
-            \class_exists($theClass, false)) {
-            $argumentsValid = true;
-
-            if ($name == '') {
-                $name = $theClass;
-            }
-
-            $theClass = new ReflectionClass($theClass);
-        } elseif (\is_string($theClass)) {
-            $this->setName($theClass);
-
-            return;
-        }
-
-        if (!$argumentsValid) {
-            throw new Exception;
-        }
-
-        if (!$theClass->isSubclassOf(TestCase::class)) {
-            throw new Exception(
-                'Class "' . $theClass->name . '" does not extend PHPUnit\Framework\TestCase.'
-            );
-        }
-
-        if ($name != '') {
-            $this->setName($name);
-        } else {
-            $this->setName($theClass->getName());
-        }
-
-        $constructor = $theClass->getConstructor();
-
-        if ($constructor !== null &&
-            !$constructor->isPublic()) {
-            $this->addTest(
-                self::warning(
-                    \sprintf(
-                        'Class "%s" has no public constructor.',
-                        $theClass->getName()
-                    )
-                )
-            );
-
-            return;
-        }
-
-        foreach ($theClass->getMethods() as $method) {
-            $this->addTestMethod($theClass, $method);
-        }
-
-        if (empty($this->tests)) {
-            $this->addTest(
-                self::warning(
-                    \sprintf(
-                        'No tests found in class "%s".',
-                        $theClass->getName()
-                    )
-                )
-            );
-        }
-
-        $this->testCase = true;
-    }
-
-    /**
-     * Returns a string representation of the test suite.
-     *
-     * @return string
-     */
-    public function toString()
-    {
-        return $this->getName();
-    }
-
-    /**
-     * Adds a test to the suite.
-     *
-     * @param Test  $test
-     * @param array $groups
-     */
-    public function addTest(Test $test, $groups = [])
-    {
-        $class = new ReflectionClass($test);
-
-        if (!$class->isAbstract()) {
-            $this->tests[]  = $test;
-            $this->numTests = -1;
-
-            if ($test instanceof self && empty($groups)) {
-                $groups = $test->getGroups();
-            }
-
-            if (empty($groups)) {
-                $groups = ['default'];
-            }
-
-            foreach ($groups as $group) {
-                if (!isset($this->groups[$group])) {
-                    $this->groups[$group] = [$test];
-                } else {
-                    $this->groups[$group][] = $test;
-                }
-            }
-
-            if ($test instanceof TestCase) {
-                $test->setGroups($groups);
-            }
-        }
-    }
-
-    /**
-     * Adds the tests from the given class to the suite.
-     *
-     * @param mixed $testClass
-     *
-     * @throws Exception
-     */
-    public function addTestSuite($testClass)
-    {
-        if (\is_string($testClass) && \class_exists($testClass)) {
-            $testClass = new ReflectionClass($testClass);
-        }
-
-        if (!\is_object($testClass)) {
-            throw InvalidArgumentHelper::factory(
-                1,
-                'class name or object'
-            );
-        }
-
-        if ($testClass instanceof self) {
-            $this->addTest($testClass);
-        } elseif ($testClass instanceof ReflectionClass) {
-            $suiteMethod = false;
-
-            if (!$testClass->isAbstract() && $testClass->hasMethod(BaseTestRunner::SUITE_METHODNAME)) {
-                $method = $testClass->getMethod(
-                    BaseTestRunner::SUITE_METHODNAME
-                );
-
-                if ($method->isStatic()) {
-                    $this->addTest(
-                        $method->invoke(null, $testClass->getName())
-                    );
-
-                    $suiteMethod = true;
-                }
-            }
-
-            if (!$suiteMethod && !$testClass->isAbstract()) {
-                $this->addTest(new self($testClass));
-            }
-        } else {
-            throw new Exception;
-        }
-    }
-
-    /**
-     * Wraps both <code>addTest()</code> and <code>addTestSuite</code>
-     * as well as the separate import statements for the user's convenience.
-     *
-     * If the named file cannot be read or there are no new tests that can be
-     * added, a <code>PHPUnit\Framework\WarningTestCase</code> will be created instead,
-     * leaving the current test run untouched.
-     *
-     * @param string $filename
-     *
-     * @throws Exception
-     */
-    public function addTestFile($filename)
-    {
-        if (!\is_string($filename)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (\file_exists($filename) && \substr($filename, -5) == '.phpt') {
-            $this->addTest(
-                new PhptTestCase($filename)
-            );
-
-            return;
-        }
-
-        // The given file may contain further stub classes in addition to the
-        // test class itself. Figure out the actual test class.
-        $classes    = \get_declared_classes();
-        $filename   = Fileloader::checkAndLoad($filename);
-        $newClasses = \array_diff(\get_declared_classes(), $classes);
-
-        // The diff is empty in case a parent class (with test methods) is added
-        // AFTER a child class that inherited from it. To account for that case,
-        // accumulate all discovered classes, so the parent class may be found in
-        // a later invocation.
-        if (!empty($newClasses)) {
-            // On the assumption that test classes are defined first in files,
-            // process discovered classes in approximate LIFO order, so as to
-            // avoid unnecessary reflection.
-            $this->foundClasses = \array_merge($newClasses, $this->foundClasses);
-        }
-
-        // The test class's name must match the filename, either in full, or as
-        // a PEAR/PSR-0 prefixed shortname ('NameSpace_ShortName'), or as a
-        // PSR-1 local shortname ('NameSpace\ShortName'). The comparison must be
-        // anchored to prevent false-positive matches (e.g., 'OtherShortName').
-        $shortname      = \basename($filename, '.php');
-        $shortnameRegEx = '/(?:^|_|\\\\)' . \preg_quote($shortname, '/') . '$/';
-
-        foreach ($this->foundClasses as $i => $className) {
-            if (\preg_match($shortnameRegEx, $className)) {
-                $class = new ReflectionClass($className);
-
-                if ($class->getFileName() == $filename) {
-                    $newClasses = [$className];
-                    unset($this->foundClasses[$i]);
-
-                    break;
-                }
-            }
-        }
-
-        foreach ($newClasses as $className) {
-            $class = new ReflectionClass($className);
-
-            if (!$class->isAbstract()) {
-                if ($class->hasMethod(BaseTestRunner::SUITE_METHODNAME)) {
-                    $method = $class->getMethod(
-                        BaseTestRunner::SUITE_METHODNAME
-                    );
-
-                    if ($method->isStatic()) {
-                        $this->addTest($method->invoke(null, $className));
-                    }
-                } elseif ($class->implementsInterface(Test::class)) {
-                    $this->addTestSuite($class);
-                }
-            }
-        }
-
-        $this->numTests = -1;
-    }
-
-    /**
-     * Wrapper for addTestFile() that adds multiple test files.
-     *
-     * @param array|Iterator $filenames
-     *
-     * @throws Exception
-     */
-    public function addTestFiles($filenames)
-    {
-        if (!(\is_array($filenames) ||
-            (\is_object($filenames) && $filenames instanceof Iterator))) {
-            throw InvalidArgumentHelper::factory(
-                1,
-                'array or iterator'
-            );
-        }
-
-        foreach ($filenames as $filename) {
-            $this->addTestFile((string) $filename);
-        }
-    }
-
-    /**
-     * Counts the number of test cases that will be run by this test.
-     *
-     * @param bool $preferCache Indicates if cache is preferred.
-     *
-     * @return int
-     */
-    public function count($preferCache = false)
-    {
-        if ($preferCache && $this->cachedNumTests !== null) {
-            return $this->cachedNumTests;
-        }
-
-        $numTests = 0;
-
-        foreach ($this as $test) {
-            $numTests += \count($test);
-        }
-
-        $this->cachedNumTests = $numTests;
-
-        return $numTests;
-    }
-
-    /**
-     * @param ReflectionClass $theClass
-     * @param string          $name
-     *
-     * @return Test
-     *
-     * @throws Exception
-     */
-    public static function createTest(ReflectionClass $theClass, $name)
-    {
-        $className = $theClass->getName();
-
-        if (!$theClass->isInstantiable()) {
-            return self::warning(
-                \sprintf('Cannot instantiate class "%s".', $className)
-            );
-        }
-
-        $backupSettings = \PHPUnit\Util\Test::getBackupSettings(
-            $className,
-            $name
-        );
-
-        $preserveGlobalState = \PHPUnit\Util\Test::getPreserveGlobalStateSettings(
-            $className,
-            $name
-        );
-
-        $runTestInSeparateProcess = \PHPUnit\Util\Test::getProcessIsolationSettings(
-            $className,
-            $name
-        );
-
-        $runClassInSeparateProcess = \PHPUnit\Util\Test::getClassProcessIsolationSettings(
-            $className,
-            $name
-        );
-
-        $constructor = $theClass->getConstructor();
-
-        if ($constructor !== null) {
-            $parameters = $constructor->getParameters();
-
-            // TestCase() or TestCase($name)
-            if (\count($parameters) < 2) {
-                $test = new $className;
-            } // TestCase($name, $data)
-            else {
-                try {
-                    $data = \PHPUnit\Util\Test::getProvidedData(
-                        $className,
-                        $name
-                    );
-                } catch (IncompleteTestError $e) {
-                    $message = \sprintf(
-                        'Test for %s::%s marked incomplete by data provider',
-                        $className,
-                        $name
-                    );
-
-                    $_message = $e->getMessage();
-
-                    if (!empty($_message)) {
-                        $message .= "\n" . $_message;
-                    }
-
-                    $data = self::incompleteTest($className, $name, $message);
-                } catch (SkippedTestError $e) {
-                    $message = \sprintf(
-                        'Test for %s::%s skipped by data provider',
-                        $className,
-                        $name
-                    );
-
-                    $_message = $e->getMessage();
-
-                    if (!empty($_message)) {
-                        $message .= "\n" . $_message;
-                    }
-
-                    $data = self::skipTest($className, $name, $message);
-                } catch (Throwable $_t) {
-                    $t = $_t;
-                } catch (Exception $_t) {
-                    $t = $_t;
-                }
-
-                if (isset($t)) {
-                    $message = \sprintf(
-                        'The data provider specified for %s::%s is invalid.',
-                        $className,
-                        $name
-                    );
-
-                    $_message = $t->getMessage();
-
-                    if (!empty($_message)) {
-                        $message .= "\n" . $_message;
-                    }
-
-                    $data = self::warning($message);
-                }
-
-                // Test method with @dataProvider.
-                if (isset($data)) {
-                    $test = new DataProviderTestSuite(
-                        $className . '::' . $name
-                    );
-
-                    if (empty($data)) {
-                        $data = self::warning(
-                            \sprintf(
-                                'No tests found in suite "%s".',
-                                $test->getName()
-                            )
-                        );
-                    }
-
-                    $groups = \PHPUnit\Util\Test::getGroups($className, $name);
-
-                    if ($data instanceof WarningTestCase ||
-                        $data instanceof SkippedTestCase ||
-                        $data instanceof IncompleteTestCase) {
-                        $test->addTest($data, $groups);
-                    } else {
-                        foreach ($data as $_dataName => $_data) {
-                            $_test = new $className($name, $_data, $_dataName);
-
-                            if ($runTestInSeparateProcess) {
-                                $_test->setRunTestInSeparateProcess(true);
-
-                                if ($preserveGlobalState !== null) {
-                                    $_test->setPreserveGlobalState($preserveGlobalState);
-                                }
-                            }
-
-                            if ($runClassInSeparateProcess) {
-                                $_test->setRunClassInSeparateProcess(true);
-
-                                if ($preserveGlobalState !== null) {
-                                    $_test->setPreserveGlobalState($preserveGlobalState);
-                                }
-                            }
-
-                            if ($backupSettings['backupGlobals'] !== null) {
-                                $_test->setBackupGlobals(
-                                    $backupSettings['backupGlobals']
-                                );
-                            }
-
-                            if ($backupSettings['backupStaticAttributes'] !== null) {
-                                $_test->setBackupStaticAttributes(
-                                    $backupSettings['backupStaticAttributes']
-                                );
-                            }
-
-                            $test->addTest($_test, $groups);
-                        }
-                    }
-                } else {
-                    $test = new $className;
-                }
-            }
-        }
-
-        if (!isset($test)) {
-            throw new Exception('No valid test provided.');
-        }
-
-        if ($test instanceof TestCase) {
-            $test->setName($name);
-
-            if ($runTestInSeparateProcess) {
-                $test->setRunTestInSeparateProcess(true);
-
-                if ($preserveGlobalState !== null) {
-                    $test->setPreserveGlobalState($preserveGlobalState);
-                }
-            }
-
-            if ($backupSettings['backupGlobals'] !== null) {
-                $test->setBackupGlobals($backupSettings['backupGlobals']);
-            }
-
-            if ($backupSettings['backupStaticAttributes'] !== null) {
-                $test->setBackupStaticAttributes(
-                    $backupSettings['backupStaticAttributes']
-                );
-            }
-        }
-
-        return $test;
-    }
-
-    /**
-     * Creates a default TestResult object.
-     *
-     * @return TestResult
-     */
-    protected function createResult()
-    {
-        return new TestResult;
-    }
-
-    /**
-     * Returns the name of the suite.
-     *
-     * @return string
-     */
-    public function getName()
-    {
-        return $this->name;
-    }
-
-    /**
-     * Returns the test groups of the suite.
-     *
-     * @return array
-     */
-    public function getGroups()
-    {
-        return \array_keys($this->groups);
-    }
-
-    public function getGroupDetails()
-    {
-        return $this->groups;
-    }
-
-    /**
-     * Set tests groups of the test case
-     *
-     * @param array $groups
-     */
-    public function setGroupDetails(array $groups)
-    {
-        $this->groups = $groups;
-    }
-
-    /**
-     * Runs the tests and collects their result in a TestResult.
-     *
-     * @param TestResult $result
-     *
-     * @return TestResult
-     */
-    public function run(TestResult $result = null)
-    {
-        if ($result === null) {
-            $result = $this->createResult();
-        }
-
-        if (\count($this) == 0) {
-            return $result;
-        }
-
-        $hookMethods = \PHPUnit\Util\Test::getHookMethods($this->name);
-
-        $result->startTestSuite($this);
-
-        try {
-            $this->setUp();
-
-            foreach ($hookMethods['beforeClass'] as $beforeClassMethod) {
-                if ($this->testCase === true &&
-                    \class_exists($this->name, false) &&
-                    \method_exists($this->name, $beforeClassMethod)) {
-                    if ($missingRequirements = \PHPUnit\Util\Test::getMissingRequirements($this->name, $beforeClassMethod)) {
-                        $this->markTestSuiteSkipped(\implode(PHP_EOL, $missingRequirements));
-                    }
-
-                    \call_user_func([$this->name, $beforeClassMethod]);
-                }
-            }
-        } catch (SkippedTestSuiteError $e) {
-            $numTests = \count($this);
-
-            for ($i = 0; $i < $numTests; $i++) {
-                $result->startTest($this);
-                $result->addFailure($this, $e, 0);
-                $result->endTest($this, 0);
-            }
-
-            $this->tearDown();
-            $result->endTestSuite($this);
-
-            return $result;
-        } catch (Throwable $_t) {
-            $t = $_t;
-        } catch (Exception $_t) {
-            $t = $_t;
-        }
-
-        if (isset($t)) {
-            $numTests = \count($this);
-
-            for ($i = 0; $i < $numTests; $i++) {
-                if ($result->shouldStop()) {
-                    break;
-                }
-
-                $result->startTest($this);
-                $result->addError($this, $t, 0);
-                $result->endTest($this, 0);
-            }
-
-            $this->tearDown();
-            $result->endTestSuite($this);
-
-            return $result;
-        }
-
-        foreach ($this as $test) {
-            if ($result->shouldStop()) {
-                break;
-            }
-
-            if ($test instanceof TestCase || $test instanceof self) {
-                $test->setbeStrictAboutChangesToGlobalState($this->beStrictAboutChangesToGlobalState);
-                $test->setBackupGlobals($this->backupGlobals);
-                $test->setBackupStaticAttributes($this->backupStaticAttributes);
-                $test->setRunTestInSeparateProcess($this->runTestInSeparateProcess);
-            }
-
-            $test->run($result);
-        }
-
-        foreach ($hookMethods['afterClass'] as $afterClassMethod) {
-            if ($this->testCase === true && \class_exists($this->name, false) && \method_exists($this->name, $afterClassMethod)) {
-                \call_user_func([$this->name, $afterClassMethod]);
-            }
-        }
-
-        $this->tearDown();
-
-        $result->endTestSuite($this);
-
-        return $result;
-    }
-
-    /**
-     * @param bool $runTestInSeparateProcess
-     *
-     * @throws Exception
-     */
-    public function setRunTestInSeparateProcess($runTestInSeparateProcess)
-    {
-        if (\is_bool($runTestInSeparateProcess)) {
-            $this->runTestInSeparateProcess = $runTestInSeparateProcess;
-        } else {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-    }
-
-    /**
-     * Runs a test.
-     *
-     * @deprecated
-     *
-     * @param Test       $test
-     * @param TestResult $result
-     */
-    public function runTest(Test $test, TestResult $result)
-    {
-        $test->run($result);
-    }
-
-    /**
-     * Sets the name of the suite.
-     *
-     * @param  string
-     */
-    public function setName($name)
-    {
-        $this->name = $name;
-    }
-
-    /**
-     * Returns the test at the given index.
-     *
-     * @param  int|false
-     *
-     * @return Test|false
-     */
-    public function testAt($index)
-    {
-        if (isset($this->tests[$index])) {
-            return $this->tests[$index];
-        }
-
-        return false;
-    }
-
-    /**
-     * Returns the tests as an enumeration.
-     *
-     * @return array
-     */
-    public function tests()
-    {
-        return $this->tests;
-    }
-
-    /**
-     * Set tests of the test suite
-     *
-     * @param array $tests
-     */
-    public function setTests(array $tests)
-    {
-        $this->tests = $tests;
-    }
-
-    /**
-     * Mark the test suite as skipped.
-     *
-     * @param string $message
-     *
-     * @throws SkippedTestSuiteError
-     */
-    public function markTestSuiteSkipped($message = '')
-    {
-        throw new SkippedTestSuiteError($message);
-    }
-
-    /**
-     * @param ReflectionClass  $class
-     * @param ReflectionMethod $method
-     */
-    protected function addTestMethod(ReflectionClass $class, ReflectionMethod $method)
-    {
-        if (!$this->isTestMethod($method)) {
-            return;
-        }
-
-        $name = $method->getName();
-
-        if (!$method->isPublic()) {
-            $this->addTest(
-                self::warning(
-                    \sprintf(
-                        'Test method "%s" in test class "%s" is not public.',
-                        $name,
-                        $class->getName()
-                    )
-                )
-            );
-
-            return;
-        }
-
-        $test = self::createTest($class, $name);
-
-        if ($test instanceof TestCase || $test instanceof DataProviderTestSuite) {
-            $test->setDependencies(
-                \PHPUnit\Util\Test::getDependencies($class->getName(), $name)
-            );
-        }
-
-        $this->addTest(
-            $test,
-            \PHPUnit\Util\Test::getGroups($class->getName(), $name)
-        );
-    }
-
-    /**
-     * @param ReflectionMethod $method
-     *
-     * @return bool
-     */
-    public static function isTestMethod(ReflectionMethod $method)
-    {
-        if (\strpos($method->name, 'test') === 0) {
-            return true;
-        }
-
-        // @scenario on TestCase::testMethod()
-        // @test     on TestCase::testMethod()
-        $docComment = $method->getDocComment();
-
-        return \strpos($docComment, '@test') !== false ||
-            \strpos($docComment, '@scenario') !== false;
-    }
-
-    /**
-     * @param string $message
-     *
-     * @return WarningTestCase
-     */
-    protected static function warning($message)
-    {
-        return new WarningTestCase($message);
-    }
-
-    /**
-     * @param string $class
-     * @param string $methodName
-     * @param string $message
-     *
-     * @return SkippedTestCase
-     */
-    protected static function skipTest($class, $methodName, $message)
-    {
-        return new SkippedTestCase($class, $methodName, $message);
-    }
-
-    /**
-     * @param string $class
-     * @param string $methodName
-     * @param string $message
-     *
-     * @return IncompleteTestCase
-     */
-    protected static function incompleteTest($class, $methodName, $message)
-    {
-        return new IncompleteTestCase($class, $methodName, $message);
-    }
-
-    /**
-     * @param bool $beStrictAboutChangesToGlobalState
-     */
-    public function setbeStrictAboutChangesToGlobalState($beStrictAboutChangesToGlobalState)
-    {
-        if (null === $this->beStrictAboutChangesToGlobalState && \is_bool($beStrictAboutChangesToGlobalState)) {
-            $this->beStrictAboutChangesToGlobalState = $beStrictAboutChangesToGlobalState;
-        }
-    }
-
-    /**
-     * @param bool $backupGlobals
-     */
-    public function setBackupGlobals($backupGlobals)
-    {
-        if (null === $this->backupGlobals && \is_bool($backupGlobals)) {
-            $this->backupGlobals = $backupGlobals;
-        }
-    }
-
-    /**
-     * @param bool $backupStaticAttributes
-     */
-    public function setBackupStaticAttributes($backupStaticAttributes)
-    {
-        if (null === $this->backupStaticAttributes && \is_bool($backupStaticAttributes)) {
-            $this->backupStaticAttributes = $backupStaticAttributes;
-        }
-    }
-
-    /**
-     * Returns an iterator for this test suite.
-     *
-     * @return TestSuiteIterator
-     */
-    public function getIterator()
-    {
-        $iterator = new TestSuiteIterator($this);
-
-        if ($this->iteratorFilter !== null) {
-            $iterator = $this->iteratorFilter->factory($iterator, $this);
-        }
-
-        return $iterator;
-    }
-
-    public function injectFilter(Factory $filter)
-    {
-        $this->iteratorFilter = $filter;
-        foreach ($this as $test) {
-            if ($test instanceof self) {
-                $test->injectFilter($filter);
-            }
-        }
-    }
-
-    /**
-     * Template Method that is called before the tests
-     * of this test suite are run.
-     */
-    protected function setUp()
-    {
-    }
-
-    /**
-     * Template Method that is called after the tests
-     * of this test suite have finished running.
-     */
-    protected function tearDown()
-    {
-    }
+	/**
+	 * Last count of tests in this suite.
+	 *
+	 * @var int|null
+	 */
+	private $cachedNumTests;
+
+	/**
+	 * Enable or disable the backup and restoration of the $GLOBALS array.
+	 *
+	 * @var bool
+	 */
+	protected $backupGlobals;
+
+	/**
+	 * Enable or disable the backup and restoration of static attributes.
+	 *
+	 * @var bool
+	 */
+	protected $backupStaticAttributes;
+
+	/**
+	 * @var bool
+	 */
+	private $beStrictAboutChangesToGlobalState;
+
+	/**
+	 * @var bool
+	 */
+	protected $runTestInSeparateProcess = false;
+
+	/**
+	 * The name of the test suite.
+	 *
+	 * @var string
+	 */
+	protected $name = '';
+
+	/**
+	 * The test groups of the test suite.
+	 *
+	 * @var array
+	 */
+	protected $groups = [];
+
+	/**
+	 * The tests in the test suite.
+	 *
+	 * @var TestCase[]
+	 */
+	protected $tests = [];
+
+	/**
+	 * The number of tests in the test suite.
+	 *
+	 * @var int
+	 */
+	protected $numTests = -1;
+
+	/**
+	 * @var bool
+	 */
+	protected $testCase = false;
+
+	/**
+	 * @var array
+	 */
+	protected $foundClasses = [];
+
+	/**
+	 * @var Factory
+	 */
+	private $iteratorFilter;
+
+	/**
+	 * Constructs a new TestSuite:
+	 *
+	 *   - PHPUnit\Framework\TestSuite() constructs an empty TestSuite.
+	 *
+	 *   - PHPUnit\Framework\TestSuite(ReflectionClass) constructs a
+	 *     TestSuite from the given class.
+	 *
+	 *   - PHPUnit\Framework\TestSuite(ReflectionClass, String)
+	 *     constructs a TestSuite from the given class with the given
+	 *     name.
+	 *
+	 *   - PHPUnit\Framework\TestSuite(String) either constructs a
+	 *     TestSuite from the given class (if the passed string is the
+	 *     name of an existing class) or constructs an empty TestSuite
+	 *     with the given name.
+	 *
+	 * @param mixed  $theClass
+	 * @param string $name
+	 *
+	 * @throws Exception
+	 */
+	public function __construct($theClass = '', $name = '')
+	{
+		$argumentsValid = false;
+
+		if (\is_object($theClass) &&
+			$theClass instanceof ReflectionClass) {
+			$argumentsValid = true;
+		} elseif (\is_string($theClass) &&
+			$theClass !== '' &&
+			\class_exists($theClass, false)) {
+			$argumentsValid = true;
+
+			if ($name == '') {
+				$name = $theClass;
+			}
+
+			$theClass = new ReflectionClass($theClass);
+		} elseif (\is_string($theClass)) {
+			$this->setName($theClass);
+
+			return;
+		}
+
+		if (!$argumentsValid) {
+			throw new Exception;
+		}
+
+		if (!$theClass->isSubclassOf(TestCase::class)) {
+			throw new Exception(
+				'Class "' . $theClass->name . '" does not extend PHPUnit\Framework\TestCase.'
+			);
+		}
+
+		if ($name != '') {
+			$this->setName($name);
+		} else {
+			$this->setName($theClass->getName());
+		}
+
+		$constructor = $theClass->getConstructor();
+
+		if ($constructor !== null &&
+			!$constructor->isPublic()) {
+			$this->addTest(
+				self::warning(
+					\sprintf(
+						'Class "%s" has no public constructor.',
+						$theClass->getName()
+					)
+				)
+			);
+
+			return;
+		}
+
+		foreach ($theClass->getMethods() as $method) {
+			$this->addTestMethod($theClass, $method);
+		}
+
+		if (empty($this->tests)) {
+			$this->addTest(
+				self::warning(
+					\sprintf(
+						'No tests found in class "%s".',
+						$theClass->getName()
+					)
+				)
+			);
+		}
+
+		$this->testCase = true;
+	}
+
+	/**
+	 * Returns a string representation of the test suite.
+	 *
+	 * @return string
+	 */
+	public function toString()
+	{
+		return $this->getName();
+	}
+
+	/**
+	 * Adds a test to the suite.
+	 *
+	 * @param Test  $test
+	 * @param array $groups
+	 */
+	public function addTest(Test $test, $groups = [])
+	{
+		$class = new ReflectionClass($test);
+
+		if (!$class->isAbstract()) {
+			$this->tests[]  = $test;
+			$this->numTests = -1;
+
+			if ($test instanceof self && empty($groups)) {
+				$groups = $test->getGroups();
+			}
+
+			if (empty($groups)) {
+				$groups = ['default'];
+			}
+
+			foreach ($groups as $group) {
+				if (!isset($this->groups[$group])) {
+					$this->groups[$group] = [$test];
+				} else {
+					$this->groups[$group][] = $test;
+				}
+			}
+
+			if ($test instanceof TestCase) {
+				$test->setGroups($groups);
+			}
+		}
+	}
+
+	/**
+	 * Adds the tests from the given class to the suite.
+	 *
+	 * @param mixed $testClass
+	 *
+	 * @throws Exception
+	 */
+	public function addTestSuite($testClass)
+	{
+		if (\is_string($testClass) && \class_exists($testClass)) {
+			$testClass = new ReflectionClass($testClass);
+		}
+
+		if (!\is_object($testClass)) {
+			throw InvalidArgumentHelper::factory(
+				1,
+				'class name or object'
+			);
+		}
+
+		if ($testClass instanceof self) {
+			$this->addTest($testClass);
+		} elseif ($testClass instanceof ReflectionClass) {
+			$suiteMethod = false;
+
+			if (!$testClass->isAbstract() && $testClass->hasMethod(BaseTestRunner::SUITE_METHODNAME)) {
+				$method = $testClass->getMethod(
+					BaseTestRunner::SUITE_METHODNAME
+				);
+
+				if ($method->isStatic()) {
+					$this->addTest(
+						$method->invoke(null, $testClass->getName())
+					);
+
+					$suiteMethod = true;
+				}
+			}
+
+			if (!$suiteMethod && !$testClass->isAbstract()) {
+				$this->addTest(new self($testClass));
+			}
+		} else {
+			throw new Exception;
+		}
+	}
+
+	/**
+	 * Wraps both <code>addTest()</code> and <code>addTestSuite</code>
+	 * as well as the separate import statements for the user's convenience.
+	 *
+	 * If the named file cannot be read or there are no new tests that can be
+	 * added, a <code>PHPUnit\Framework\WarningTestCase</code> will be created instead,
+	 * leaving the current test run untouched.
+	 *
+	 * @param string $filename
+	 *
+	 * @throws Exception
+	 */
+	public function addTestFile($filename)
+	{
+		if (!\is_string($filename)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (\file_exists($filename) && \substr($filename, -5) == '.phpt') {
+			$this->addTest(
+				new PhptTestCase($filename)
+			);
+
+			return;
+		}
+
+		// The given file may contain further stub classes in addition to the
+		// test class itself. Figure out the actual test class.
+		$classes    = \get_declared_classes();
+		$filename   = Fileloader::checkAndLoad($filename);
+		$newClasses = \array_diff(\get_declared_classes(), $classes);
+
+		// The diff is empty in case a parent class (with test methods) is added
+		// AFTER a child class that inherited from it. To account for that case,
+		// accumulate all discovered classes, so the parent class may be found in
+		// a later invocation.
+		if (!empty($newClasses)) {
+			// On the assumption that test classes are defined first in files,
+			// process discovered classes in approximate LIFO order, so as to
+			// avoid unnecessary reflection.
+			$this->foundClasses = \array_merge($newClasses, $this->foundClasses);
+		}
+
+		// The test class's name must match the filename, either in full, or as
+		// a PEAR/PSR-0 prefixed shortname ('NameSpace_ShortName'), or as a
+		// PSR-1 local shortname ('NameSpace\ShortName'). The comparison must be
+		// anchored to prevent false-positive matches (e.g., 'OtherShortName').
+		$shortname      = \basename($filename, '.php');
+		$shortnameRegEx = '/(?:^|_|\\\\)' . \preg_quote($shortname, '/') . '$/';
+
+		foreach ($this->foundClasses as $i => $className) {
+			if (\preg_match($shortnameRegEx, $className)) {
+				$class = new ReflectionClass($className);
+
+				if ($class->getFileName() == $filename) {
+					$newClasses = [$className];
+					unset($this->foundClasses[$i]);
+
+					break;
+				}
+			}
+		}
+
+		foreach ($newClasses as $className) {
+			$class = new ReflectionClass($className);
+
+			if (!$class->isAbstract()) {
+				if ($class->hasMethod(BaseTestRunner::SUITE_METHODNAME)) {
+					$method = $class->getMethod(
+						BaseTestRunner::SUITE_METHODNAME
+					);
+
+					if ($method->isStatic()) {
+						$this->addTest($method->invoke(null, $className));
+					}
+				} elseif ($class->implementsInterface(Test::class)) {
+					$this->addTestSuite($class);
+				}
+			}
+		}
+
+		$this->numTests = -1;
+	}
+
+	/**
+	 * Wrapper for addTestFile() that adds multiple test files.
+	 *
+	 * @param array|Iterator $filenames
+	 *
+	 * @throws Exception
+	 */
+	public function addTestFiles($filenames)
+	{
+		if (!(\is_array($filenames) ||
+			(\is_object($filenames) && $filenames instanceof Iterator))) {
+			throw InvalidArgumentHelper::factory(
+				1,
+				'array or iterator'
+			);
+		}
+
+		foreach ($filenames as $filename) {
+			$this->addTestFile((string) $filename);
+		}
+	}
+
+	/**
+	 * Counts the number of test cases that will be run by this test.
+	 *
+	 * @param bool $preferCache Indicates if cache is preferred.
+	 *
+	 * @return int
+	 */
+	public function count($preferCache = false)
+	{
+		if ($preferCache && $this->cachedNumTests !== null) {
+			return $this->cachedNumTests;
+		}
+
+		$numTests = 0;
+
+		foreach ($this as $test) {
+			$numTests += \count($test);
+		}
+
+		$this->cachedNumTests = $numTests;
+
+		return $numTests;
+	}
+
+	/**
+	 * @param ReflectionClass $theClass
+	 * @param string          $name
+	 *
+	 * @return Test
+	 *
+	 * @throws Exception
+	 */
+	public static function createTest(ReflectionClass $theClass, $name)
+	{
+		$className = $theClass->getName();
+
+		if (!$theClass->isInstantiable()) {
+			return self::warning(
+				\sprintf('Cannot instantiate class "%s".', $className)
+			);
+		}
+
+		$backupSettings = \PHPUnit\Util\Test::getBackupSettings(
+			$className,
+			$name
+		);
+
+		$preserveGlobalState = \PHPUnit\Util\Test::getPreserveGlobalStateSettings(
+			$className,
+			$name
+		);
+
+		$runTestInSeparateProcess = \PHPUnit\Util\Test::getProcessIsolationSettings(
+			$className,
+			$name
+		);
+
+		$runClassInSeparateProcess = \PHPUnit\Util\Test::getClassProcessIsolationSettings(
+			$className,
+			$name
+		);
+
+		$constructor = $theClass->getConstructor();
+
+		if ($constructor !== null) {
+			$parameters = $constructor->getParameters();
+
+			// TestCase() or TestCase($name)
+			if (\count($parameters) < 2) {
+				$test = new $className;
+			} // TestCase($name, $data)
+			else {
+				try {
+					$data = \PHPUnit\Util\Test::getProvidedData(
+						$className,
+						$name
+					);
+				} catch (IncompleteTestError $e) {
+					$message = \sprintf(
+						'Test for %s::%s marked incomplete by data provider',
+						$className,
+						$name
+					);
+
+					$_message = $e->getMessage();
+
+					if (!empty($_message)) {
+						$message .= "\n" . $_message;
+					}
+
+					$data = self::incompleteTest($className, $name, $message);
+				} catch (SkippedTestError $e) {
+					$message = \sprintf(
+						'Test for %s::%s skipped by data provider',
+						$className,
+						$name
+					);
+
+					$_message = $e->getMessage();
+
+					if (!empty($_message)) {
+						$message .= "\n" . $_message;
+					}
+
+					$data = self::skipTest($className, $name, $message);
+				} catch (Throwable $_t) {
+					$t = $_t;
+				} catch (Exception $_t) {
+					$t = $_t;
+				}
+
+				if (isset($t)) {
+					$message = \sprintf(
+						'The data provider specified for %s::%s is invalid.',
+						$className,
+						$name
+					);
+
+					$_message = $t->getMessage();
+
+					if (!empty($_message)) {
+						$message .= "\n" . $_message;
+					}
+
+					$data = self::warning($message);
+				}
+
+				// Test method with @dataProvider.
+				if (isset($data)) {
+					$test = new DataProviderTestSuite(
+						$className . '::' . $name
+					);
+
+					if (empty($data)) {
+						$data = self::warning(
+							\sprintf(
+								'No tests found in suite "%s".',
+								$test->getName()
+							)
+						);
+					}
+
+					$groups = \PHPUnit\Util\Test::getGroups($className, $name);
+
+					if ($data instanceof WarningTestCase ||
+						$data instanceof SkippedTestCase ||
+						$data instanceof IncompleteTestCase) {
+						$test->addTest($data, $groups);
+					} else {
+						foreach ($data as $_dataName => $_data) {
+							$_test = new $className($name, $_data, $_dataName);
+
+							if ($runTestInSeparateProcess) {
+								$_test->setRunTestInSeparateProcess(true);
+
+								if ($preserveGlobalState !== null) {
+									$_test->setPreserveGlobalState($preserveGlobalState);
+								}
+							}
+
+							if ($runClassInSeparateProcess) {
+								$_test->setRunClassInSeparateProcess(true);
+
+								if ($preserveGlobalState !== null) {
+									$_test->setPreserveGlobalState($preserveGlobalState);
+								}
+							}
+
+							if ($backupSettings['backupGlobals'] !== null) {
+								$_test->setBackupGlobals(
+									$backupSettings['backupGlobals']
+								);
+							}
+
+							if ($backupSettings['backupStaticAttributes'] !== null) {
+								$_test->setBackupStaticAttributes(
+									$backupSettings['backupStaticAttributes']
+								);
+							}
+
+							$test->addTest($_test, $groups);
+						}
+					}
+				} else {
+					$test = new $className;
+				}
+			}
+		}
+
+		if (!isset($test)) {
+			throw new Exception('No valid test provided.');
+		}
+
+		if ($test instanceof TestCase) {
+			$test->setName($name);
+
+			if ($runTestInSeparateProcess) {
+				$test->setRunTestInSeparateProcess(true);
+
+				if ($preserveGlobalState !== null) {
+					$test->setPreserveGlobalState($preserveGlobalState);
+				}
+			}
+
+			if ($backupSettings['backupGlobals'] !== null) {
+				$test->setBackupGlobals($backupSettings['backupGlobals']);
+			}
+
+			if ($backupSettings['backupStaticAttributes'] !== null) {
+				$test->setBackupStaticAttributes(
+					$backupSettings['backupStaticAttributes']
+				);
+			}
+		}
+
+		return $test;
+	}
+
+	/**
+	 * Creates a default TestResult object.
+	 *
+	 * @return TestResult
+	 */
+	protected function createResult()
+	{
+		return new TestResult;
+	}
+
+	/**
+	 * Returns the name of the suite.
+	 *
+	 * @return string
+	 */
+	public function getName()
+	{
+		return $this->name;
+	}
+
+	/**
+	 * Returns the test groups of the suite.
+	 *
+	 * @return array
+	 */
+	public function getGroups()
+	{
+		return \array_keys($this->groups);
+	}
+
+	public function getGroupDetails()
+	{
+		return $this->groups;
+	}
+
+	/**
+	 * Set tests groups of the test case
+	 *
+	 * @param array $groups
+	 */
+	public function setGroupDetails(array $groups)
+	{
+		$this->groups = $groups;
+	}
+
+	/**
+	 * Runs the tests and collects their result in a TestResult.
+	 *
+	 * @param TestResult $result
+	 *
+	 * @return TestResult
+	 */
+	public function run(TestResult $result = null)
+	{
+		if ($result === null) {
+			$result = $this->createResult();
+		}
+
+		if (\count($this) == 0) {
+			return $result;
+		}
+
+		$hookMethods = \PHPUnit\Util\Test::getHookMethods($this->name);
+
+		$result->startTestSuite($this);
+
+		try {
+			$this->setUp();
+
+			foreach ($hookMethods['beforeClass'] as $beforeClassMethod) {
+				if ($this->testCase === true &&
+					\class_exists($this->name, false) &&
+					\method_exists($this->name, $beforeClassMethod)) {
+					if ($missingRequirements = \PHPUnit\Util\Test::getMissingRequirements($this->name, $beforeClassMethod)) {
+						$this->markTestSuiteSkipped(\implode(PHP_EOL, $missingRequirements));
+					}
+
+					\call_user_func([$this->name, $beforeClassMethod]);
+				}
+			}
+		} catch (SkippedTestSuiteError $e) {
+			$numTests = \count($this);
+
+			for ($i = 0; $i < $numTests; $i++) {
+				$result->startTest($this);
+				$result->addFailure($this, $e, 0);
+				$result->endTest($this, 0);
+			}
+
+			$this->tearDown();
+			$result->endTestSuite($this);
+
+			return $result;
+		} catch (Throwable $_t) {
+			$t = $_t;
+		} catch (Exception $_t) {
+			$t = $_t;
+		}
+
+		if (isset($t)) {
+			$numTests = \count($this);
+
+			for ($i = 0; $i < $numTests; $i++) {
+				if ($result->shouldStop()) {
+					break;
+				}
+
+				$result->startTest($this);
+				$result->addError($this, $t, 0);
+				$result->endTest($this, 0);
+			}
+
+			$this->tearDown();
+			$result->endTestSuite($this);
+
+			return $result;
+		}
+
+		foreach ($this as $test) {
+			if ($result->shouldStop()) {
+				break;
+			}
+
+			if ($test instanceof TestCase || $test instanceof self) {
+				$test->setbeStrictAboutChangesToGlobalState($this->beStrictAboutChangesToGlobalState);
+				$test->setBackupGlobals($this->backupGlobals);
+				$test->setBackupStaticAttributes($this->backupStaticAttributes);
+				$test->setRunTestInSeparateProcess($this->runTestInSeparateProcess);
+			}
+
+			$test->run($result);
+		}
+
+		foreach ($hookMethods['afterClass'] as $afterClassMethod) {
+			if ($this->testCase === true && \class_exists($this->name, false) && \method_exists($this->name, $afterClassMethod)) {
+				\call_user_func([$this->name, $afterClassMethod]);
+			}
+		}
+
+		$this->tearDown();
+
+		$result->endTestSuite($this);
+
+		return $result;
+	}
+
+	/**
+	 * @param bool $runTestInSeparateProcess
+	 *
+	 * @throws Exception
+	 */
+	public function setRunTestInSeparateProcess($runTestInSeparateProcess)
+	{
+		if (\is_bool($runTestInSeparateProcess)) {
+			$this->runTestInSeparateProcess = $runTestInSeparateProcess;
+		} else {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+	}
+
+	/**
+	 * Runs a test.
+	 *
+	 * @deprecated
+	 *
+	 * @param Test       $test
+	 * @param TestResult $result
+	 */
+	public function runTest(Test $test, TestResult $result)
+	{
+		$test->run($result);
+	}
+
+	/**
+	 * Sets the name of the suite.
+	 *
+	 * @param  string
+	 */
+	public function setName($name)
+	{
+		$this->name = $name;
+	}
+
+	/**
+	 * Returns the test at the given index.
+	 *
+	 * @param  int|false
+	 *
+	 * @return Test|false
+	 */
+	public function testAt($index)
+	{
+		if (isset($this->tests[$index])) {
+			return $this->tests[$index];
+		}
+
+		return false;
+	}
+
+	/**
+	 * Returns the tests as an enumeration.
+	 *
+	 * @return array
+	 */
+	public function tests()
+	{
+		return $this->tests;
+	}
+
+	/**
+	 * Set tests of the test suite
+	 *
+	 * @param array $tests
+	 */
+	public function setTests(array $tests)
+	{
+		$this->tests = $tests;
+	}
+
+	/**
+	 * Mark the test suite as skipped.
+	 *
+	 * @param string $message
+	 *
+	 * @throws SkippedTestSuiteError
+	 */
+	public function markTestSuiteSkipped($message = '')
+	{
+		throw new SkippedTestSuiteError($message);
+	}
+
+	/**
+	 * @param ReflectionClass  $class
+	 * @param ReflectionMethod $method
+	 */
+	protected function addTestMethod(ReflectionClass $class, ReflectionMethod $method)
+	{
+		if (!$this->isTestMethod($method)) {
+			return;
+		}
+
+		$name = $method->getName();
+
+		if (!$method->isPublic()) {
+			$this->addTest(
+				self::warning(
+					\sprintf(
+						'Test method "%s" in test class "%s" is not public.',
+						$name,
+						$class->getName()
+					)
+				)
+			);
+
+			return;
+		}
+
+		$test = self::createTest($class, $name);
+
+		if ($test instanceof TestCase || $test instanceof DataProviderTestSuite) {
+			$test->setDependencies(
+				\PHPUnit\Util\Test::getDependencies($class->getName(), $name)
+			);
+		}
+
+		$this->addTest(
+			$test,
+			\PHPUnit\Util\Test::getGroups($class->getName(), $name)
+		);
+	}
+
+	/**
+	 * @param ReflectionMethod $method
+	 *
+	 * @return bool
+	 */
+	public static function isTestMethod(ReflectionMethod $method)
+	{
+		if (\strpos($method->name, 'test') === 0) {
+			return true;
+		}
+
+		// @scenario on TestCase::testMethod()
+		// @test     on TestCase::testMethod()
+		$docComment = $method->getDocComment();
+
+		return \strpos($docComment, '@test') !== false ||
+			\strpos($docComment, '@scenario') !== false;
+	}
+
+	/**
+	 * @param string $message
+	 *
+	 * @return WarningTestCase
+	 */
+	protected static function warning($message)
+	{
+		return new WarningTestCase($message);
+	}
+
+	/**
+	 * @param string $class
+	 * @param string $methodName
+	 * @param string $message
+	 *
+	 * @return SkippedTestCase
+	 */
+	protected static function skipTest($class, $methodName, $message)
+	{
+		return new SkippedTestCase($class, $methodName, $message);
+	}
+
+	/**
+	 * @param string $class
+	 * @param string $methodName
+	 * @param string $message
+	 *
+	 * @return IncompleteTestCase
+	 */
+	protected static function incompleteTest($class, $methodName, $message)
+	{
+		return new IncompleteTestCase($class, $methodName, $message);
+	}
+
+	/**
+	 * @param bool $beStrictAboutChangesToGlobalState
+	 */
+	public function setbeStrictAboutChangesToGlobalState($beStrictAboutChangesToGlobalState)
+	{
+		if (null === $this->beStrictAboutChangesToGlobalState && \is_bool($beStrictAboutChangesToGlobalState)) {
+			$this->beStrictAboutChangesToGlobalState = $beStrictAboutChangesToGlobalState;
+		}
+	}
+
+	/**
+	 * @param bool $backupGlobals
+	 */
+	public function setBackupGlobals($backupGlobals)
+	{
+		if (null === $this->backupGlobals && \is_bool($backupGlobals)) {
+			$this->backupGlobals = $backupGlobals;
+		}
+	}
+
+	/**
+	 * @param bool $backupStaticAttributes
+	 */
+	public function setBackupStaticAttributes($backupStaticAttributes)
+	{
+		if (null === $this->backupStaticAttributes && \is_bool($backupStaticAttributes)) {
+			$this->backupStaticAttributes = $backupStaticAttributes;
+		}
+	}
+
+	/**
+	 * Returns an iterator for this test suite.
+	 *
+	 * @return TestSuiteIterator
+	 */
+	public function getIterator()
+	{
+		$iterator = new TestSuiteIterator($this);
+
+		if ($this->iteratorFilter !== null) {
+			$iterator = $this->iteratorFilter->factory($iterator, $this);
+		}
+
+		return $iterator;
+	}
+
+	public function injectFilter(Factory $filter)
+	{
+		$this->iteratorFilter = $filter;
+		foreach ($this as $test) {
+			if ($test instanceof self) {
+				$test->injectFilter($filter);
+			}
+		}
+	}
+
+	/**
+	 * Template Method that is called before the tests
+	 * of this test suite are run.
+	 */
+	protected function setUp()
+	{
+	}
+
+	/**
+	 * Template Method that is called after the tests
+	 * of this test suite have finished running.
+	 */
+	protected function tearDown()
+	{
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -150,7 +150,7 @@ 
 
         if (!$theClass->isSubclassOf(TestCase::class)) {
             throw new Exception(
-                'Class "' . $theClass->name . '" does not extend PHPUnit\Framework\TestCase.'
+                'Class "'.$theClass->name.'" does not extend PHPUnit\Framework\TestCase.'
             );
         }
 
@@ -335,7 +335,7 @@ 
         // PSR-1 local shortname ('NameSpace\ShortName'). The comparison must be
         // anchored to prevent false-positive matches (e.g., 'OtherShortName').
         $shortname      = \basename($filename, '.php');
-        $shortnameRegEx = '/(?:^|_|\\\\)' . \preg_quote($shortname, '/') . '$/';
+        $shortnameRegEx = '/(?:^|_|\\\\)'.\preg_quote($shortname, '/').'$/';
 
         foreach ($this->foundClasses as $i => $className) {
             if (\preg_match($shortnameRegEx, $className)) {
@@ -480,7 +480,7 @@ 
                     $_message = $e->getMessage();
 
                     if (!empty($_message)) {
-                        $message .= "\n" . $_message;
+                        $message .= "\n".$_message;
                     }
 
                     $data = self::incompleteTest($className, $name, $message);
@@ -494,7 +494,7 @@ 
                     $_message = $e->getMessage();
 
                     if (!empty($_message)) {
-                        $message .= "\n" . $_message;
+                        $message .= "\n".$_message;
                     }
 
                     $data = self::skipTest($className, $name, $message);
@@ -514,7 +514,7 @@ 
                     $_message = $t->getMessage();
 
                     if (!empty($_message)) {
-                        $message .= "\n" . $_message;
+                        $message .= "\n".$_message;
                     }
 
                     $data = self::warning($message);
@@ -523,7 +523,7 @@ 
                 // Test method with @dataProvider.
                 if (isset($data)) {
                     $test = new DataProviderTestSuite(
-                        $className . '::' . $name
+                        $className.'::'.$name
                     );
 
                     if (empty($data)) {

vendor/phpunit/phpunit/src/Framework/Assert/Functions.php

Indentation +145 added lines, -145 removed lines

@@ -55,7 +55,7 @@ 
  */
 function any()
 {
-    return TestCase::any();
+	return TestCase::any();
 }
 
 /**
@@ -65,7 +65,7 @@ 
  */
 function anything()
 {
-    return Assert::anything();
+	return Assert::anything();
 }
 
 /**
@@ -77,7 +77,7 @@ 
  */
 function arrayHasKey($key)
 {
-    return Assert::arrayHasKey(...\func_get_args());
+	return Assert::arrayHasKey(...\func_get_args());
 }
 
 /**
@@ -89,7 +89,7 @@ 
  */
 function assertArrayHasKey($key, $array, $message = '')
 {
-    return Assert::assertArrayHasKey(...\func_get_args());
+	return Assert::assertArrayHasKey(...\func_get_args());
 }
 
 /**
@@ -102,7 +102,7 @@ 
  */
 function assertArraySubset($subset, $array, $strict = false, $message = '')
 {
-    return Assert::assertArraySubset(...\func_get_args());
+	return Assert::assertArraySubset(...\func_get_args());
 }
 
 /**
@@ -114,7 +114,7 @@ 
  */
 function assertArrayNotHasKey($key, $array, $message = '')
 {
-    return Assert::assertArrayNotHasKey(...\func_get_args());
+	return Assert::assertArrayNotHasKey(...\func_get_args());
 }
 
 /**
@@ -131,7 +131,7 @@ 
  */
 function assertAttributeContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
 {
-    return Assert::assertAttributeContains(...\func_get_args());
+	return Assert::assertAttributeContains(...\func_get_args());
 }
 
 /**
@@ -146,7 +146,7 @@ 
  */
 function assertAttributeContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '')
 {
-    return Assert::assertAttributeContainsOnly(...\func_get_args());
+	return Assert::assertAttributeContainsOnly(...\func_get_args());
 }
 
 /**
@@ -160,7 +160,7 @@ 
  */
 function assertAttributeCount($expectedCount, $haystackAttributeName, $haystackClassOrObject, $message = '')
 {
-    return Assert::assertAttributeCount(...\func_get_args());
+	return Assert::assertAttributeCount(...\func_get_args());
 }
 
 /**
@@ -173,7 +173,7 @@ 
  */
 function assertAttributeEmpty($haystackAttributeName, $haystackClassOrObject, $message = '')
 {
-    return Assert::assertAttributeEmpty(...\func_get_args());
+	return Assert::assertAttributeEmpty(...\func_get_args());
 }
 
 /**
@@ -190,7 +190,7 @@ 
  */
 function assertAttributeEquals($expected, $actualAttributeName, $actualClassOrObject, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::assertAttributeEquals(...\func_get_args());
+	return Assert::assertAttributeEquals(...\func_get_args());
 }
 
 /**
@@ -203,7 +203,7 @@ 
  */
 function assertAttributeGreaterThan($expected, $actualAttributeName, $actualClassOrObject, $message = '')
 {
-    return Assert::assertAttributeGreaterThan(...\func_get_args());
+	return Assert::assertAttributeGreaterThan(...\func_get_args());
 }
 
 /**
@@ -216,7 +216,7 @@ 
  */
 function assertAttributeGreaterThanOrEqual($expected, $actualAttributeName, $actualClassOrObject, $message = '')
 {
-    return Assert::assertAttributeGreaterThanOrEqual(...\func_get_args());
+	return Assert::assertAttributeGreaterThanOrEqual(...\func_get_args());
 }
 
 /**
@@ -229,7 +229,7 @@ 
  */
 function assertAttributeInstanceOf($expected, $attributeName, $classOrObject, $message = '')
 {
-    return Assert::assertAttributeInstanceOf(...\func_get_args());
+	return Assert::assertAttributeInstanceOf(...\func_get_args());
 }
 
 /**
@@ -242,7 +242,7 @@ 
  */
 function assertAttributeInternalType($expected, $attributeName, $classOrObject, $message = '')
 {
-    return Assert::assertAttributeInternalType(...\func_get_args());
+	return Assert::assertAttributeInternalType(...\func_get_args());
 }
 
 /**
@@ -255,7 +255,7 @@ 
  */
 function assertAttributeLessThan($expected, $actualAttributeName, $actualClassOrObject, $message = '')
 {
-    return Assert::assertAttributeLessThan(...\func_get_args());
+	return Assert::assertAttributeLessThan(...\func_get_args());
 }
 
 /**
@@ -268,7 +268,7 @@ 
  */
 function assertAttributeLessThanOrEqual($expected, $actualAttributeName, $actualClassOrObject, $message = '')
 {
-    return Assert::assertAttributeLessThanOrEqual(...\func_get_args());
+	return Assert::assertAttributeLessThanOrEqual(...\func_get_args());
 }
 
 /**
@@ -285,7 +285,7 @@ 
  */
 function assertAttributeNotContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
 {
-    return Assert::assertAttributeNotContains(...\func_get_args());
+	return Assert::assertAttributeNotContains(...\func_get_args());
 }
 
 /**
@@ -301,7 +301,7 @@ 
  */
 function assertAttributeNotContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '')
 {
-    return Assert::assertAttributeNotContainsOnly(...\func_get_args());
+	return Assert::assertAttributeNotContainsOnly(...\func_get_args());
 }
 
 /**
@@ -315,7 +315,7 @@ 
  */
 function assertAttributeNotCount($expectedCount, $haystackAttributeName, $haystackClassOrObject, $message = '')
 {
-    return Assert::assertAttributeNotCount(...\func_get_args());
+	return Assert::assertAttributeNotCount(...\func_get_args());
 }
 
 /**
@@ -328,7 +328,7 @@ 
  */
 function assertAttributeNotEmpty($haystackAttributeName, $haystackClassOrObject, $message = '')
 {
-    return Assert::assertAttributeNotEmpty(...\func_get_args());
+	return Assert::assertAttributeNotEmpty(...\func_get_args());
 }
 
 /**
@@ -345,7 +345,7 @@ 
  */
 function assertAttributeNotEquals($expected, $actualAttributeName, $actualClassOrObject, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::assertAttributeNotEquals(...\func_get_args());
+	return Assert::assertAttributeNotEquals(...\func_get_args());
 }
 
 /**
@@ -358,7 +358,7 @@ 
  */
 function assertAttributeNotInstanceOf($expected, $attributeName, $classOrObject, $message = '')
 {
-    return Assert::assertAttributeNotInstanceOf(...\func_get_args());
+	return Assert::assertAttributeNotInstanceOf(...\func_get_args());
 }
 
 /**
@@ -371,7 +371,7 @@ 
  */
 function assertAttributeNotInternalType($expected, $attributeName, $classOrObject, $message = '')
 {
-    return Assert::assertAttributeNotInternalType(...\func_get_args());
+	return Assert::assertAttributeNotInternalType(...\func_get_args());
 }
 
 /**
@@ -385,7 +385,7 @@ 
  */
 function assertAttributeNotSame($expected, $actualAttributeName, $actualClassOrObject, $message = '')
 {
-    return Assert::assertAttributeNotSame(...\func_get_args());
+	return Assert::assertAttributeNotSame(...\func_get_args());
 }
 
 /**
@@ -399,7 +399,7 @@ 
  */
 function assertAttributeSame($expected, $actualAttributeName, $actualClassOrObject, $message = '')
 {
-    return Assert::assertAttributeSame(...\func_get_args());
+	return Assert::assertAttributeSame(...\func_get_args());
 }
 
 /**
@@ -411,7 +411,7 @@ 
  */
 function assertClassHasAttribute($attributeName, $className, $message = '')
 {
-    return Assert::assertClassHasAttribute(...\func_get_args());
+	return Assert::assertClassHasAttribute(...\func_get_args());
 }
 
 /**
@@ -423,7 +423,7 @@ 
  */
 function assertClassHasStaticAttribute($attributeName, $className, $message = '')
 {
-    return Assert::assertClassHasStaticAttribute(...\func_get_args());
+	return Assert::assertClassHasStaticAttribute(...\func_get_args());
 }
 
 /**
@@ -435,7 +435,7 @@ 
  */
 function assertClassNotHasAttribute($attributeName, $className, $message = '')
 {
-    return Assert::assertClassNotHasAttribute(...\func_get_args());
+	return Assert::assertClassNotHasAttribute(...\func_get_args());
 }
 
 /**
@@ -447,7 +447,7 @@ 
  */
 function assertClassNotHasStaticAttribute($attributeName, $className, $message = '')
 {
-    return Assert::assertClassNotHasStaticAttribute(...\func_get_args());
+	return Assert::assertClassNotHasStaticAttribute(...\func_get_args());
 }
 
 /**
@@ -462,7 +462,7 @@ 
  */
 function assertContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
 {
-    return Assert::assertContains(...\func_get_args());
+	return Assert::assertContains(...\func_get_args());
 }
 
 /**
@@ -475,7 +475,7 @@ 
  */
 function assertContainsOnly($type, $haystack, $isNativeType = null, $message = '')
 {
-    return Assert::assertContainsOnly(...\func_get_args());
+	return Assert::assertContainsOnly(...\func_get_args());
 }
 
 /**
@@ -487,7 +487,7 @@ 
  */
 function assertContainsOnlyInstancesOf($classname, $haystack, $message = '')
 {
-    return Assert::assertContainsOnlyInstancesOf(...\func_get_args());
+	return Assert::assertContainsOnlyInstancesOf(...\func_get_args());
 }
 
 /**
@@ -499,7 +499,7 @@ 
  */
 function assertCount($expectedCount, $haystack, $message = '')
 {
-    return Assert::assertCount(...\func_get_args());
+	return Assert::assertCount(...\func_get_args());
 }
 
 /**
@@ -512,7 +512,7 @@ 
  */
 function assertEmpty($actual, $message = '')
 {
-    return Assert::assertEmpty(...\func_get_args());
+	return Assert::assertEmpty(...\func_get_args());
 }
 
 /**
@@ -525,7 +525,7 @@ 
  */
 function assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement, $checkAttributes = false, $message = '')
 {
-    return Assert::assertEqualXMLStructure(...\func_get_args());
+	return Assert::assertEqualXMLStructure(...\func_get_args());
 }
 
 /**
@@ -541,7 +541,7 @@ 
  */
 function assertEquals($expected, $actual, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::assertEquals(...\func_get_args());
+	return Assert::assertEquals(...\func_get_args());
 }
 
 /**
@@ -554,7 +554,7 @@ 
  */
 function assertNotTrue($condition, $message = '')
 {
-    return Assert::assertNotTrue(...\func_get_args());
+	return Assert::assertNotTrue(...\func_get_args());
 }
 
 /**
@@ -567,7 +567,7 @@ 
  */
 function assertFalse($condition, $message = '')
 {
-    return Assert::assertFalse(...\func_get_args());
+	return Assert::assertFalse(...\func_get_args());
 }
 
 /**
@@ -582,7 +582,7 @@ 
  */
 function assertFileEquals($expected, $actual, $message = '', $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::assertFileEquals(...\func_get_args());
+	return Assert::assertFileEquals(...\func_get_args());
 }
 
 /**
@@ -593,7 +593,7 @@ 
  */
 function assertFileExists($filename, $message = '')
 {
-    return Assert::assertFileExists(...\func_get_args());
+	return Assert::assertFileExists(...\func_get_args());
 }
 
 /**
@@ -608,7 +608,7 @@ 
  */
 function assertFileNotEquals($expected, $actual, $message = '', $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::assertFileNotEquals(...\func_get_args());
+	return Assert::assertFileNotEquals(...\func_get_args());
 }
 
 /**
@@ -619,7 +619,7 @@ 
  */
 function assertFileNotExists($filename, $message = '')
 {
-    return Assert::assertFileNotExists(...\func_get_args());
+	return Assert::assertFileNotExists(...\func_get_args());
 }
 
 /**
@@ -631,7 +631,7 @@ 
  */
 function assertGreaterThan($expected, $actual, $message = '')
 {
-    return Assert::assertGreaterThan(...\func_get_args());
+	return Assert::assertGreaterThan(...\func_get_args());
 }
 
 /**
@@ -643,7 +643,7 @@ 
  */
 function assertGreaterThanOrEqual($expected, $actual, $message = '')
 {
-    return Assert::assertGreaterThanOrEqual(...\func_get_args());
+	return Assert::assertGreaterThanOrEqual(...\func_get_args());
 }
 
 /**
@@ -655,7 +655,7 @@ 
  */
 function assertInstanceOf($expected, $actual, $message = '')
 {
-    return Assert::assertInstanceOf(...\func_get_args());
+	return Assert::assertInstanceOf(...\func_get_args());
 }
 
 /**
@@ -667,7 +667,7 @@ 
  */
 function assertInternalType($expected, $actual, $message = '')
 {
-    return Assert::assertInternalType(...\func_get_args());
+	return Assert::assertInternalType(...\func_get_args());
 }
 
 /**
@@ -678,7 +678,7 @@ 
  */
 function assertJson($actualJson, $message = '')
 {
-    return Assert::assertJson(...\func_get_args());
+	return Assert::assertJson(...\func_get_args());
 }
 
 /**
@@ -690,7 +690,7 @@ 
  */
 function assertJsonFileEqualsJsonFile($expectedFile, $actualFile, $message = '')
 {
-    return Assert::assertJsonFileEqualsJsonFile(...\func_get_args());
+	return Assert::assertJsonFileEqualsJsonFile(...\func_get_args());
 }
 
 /**
@@ -702,7 +702,7 @@ 
  */
 function assertJsonFileNotEqualsJsonFile($expectedFile, $actualFile, $message = '')
 {
-    return Assert::assertJsonFileNotEqualsJsonFile(...\func_get_args());
+	return Assert::assertJsonFileNotEqualsJsonFile(...\func_get_args());
 }
 
 /**
@@ -714,7 +714,7 @@ 
  */
 function assertJsonStringEqualsJsonFile($expectedFile, $actualJson, $message = '')
 {
-    return Assert::assertJsonStringEqualsJsonFile(...\func_get_args());
+	return Assert::assertJsonStringEqualsJsonFile(...\func_get_args());
 }
 
 /**
@@ -726,7 +726,7 @@ 
  */
 function assertJsonStringEqualsJsonString($expectedJson, $actualJson, $message = '')
 {
-    return Assert::assertJsonStringEqualsJsonString(...\func_get_args());
+	return Assert::assertJsonStringEqualsJsonString(...\func_get_args());
 }
 
 /**
@@ -738,7 +738,7 @@ 
  */
 function assertJsonStringNotEqualsJsonFile($expectedFile, $actualJson, $message = '')
 {
-    return Assert::assertJsonStringNotEqualsJsonFile(...\func_get_args());
+	return Assert::assertJsonStringNotEqualsJsonFile(...\func_get_args());
 }
 
 /**
@@ -750,7 +750,7 @@ 
  */
 function assertJsonStringNotEqualsJsonString($expectedJson, $actualJson, $message = '')
 {
-    return Assert::assertJsonStringNotEqualsJsonString(...\func_get_args());
+	return Assert::assertJsonStringNotEqualsJsonString(...\func_get_args());
 }
 
 /**
@@ -762,7 +762,7 @@ 
  */
 function assertLessThan($expected, $actual, $message = '')
 {
-    return Assert::assertLessThan(...\func_get_args());
+	return Assert::assertLessThan(...\func_get_args());
 }
 
 /**
@@ -774,7 +774,7 @@ 
  */
 function assertLessThanOrEqual($expected, $actual, $message = '')
 {
-    return Assert::assertLessThanOrEqual(...\func_get_args());
+	return Assert::assertLessThanOrEqual(...\func_get_args());
 }
 
 /**
@@ -785,7 +785,7 @@ 
  */
 function assertFinite($actual, $message = '')
 {
-    return Assert::assertFinite(...\func_get_args());
+	return Assert::assertFinite(...\func_get_args());
 }
 
 /**
@@ -796,7 +796,7 @@ 
  */
 function assertInfinite($actual, $message = '')
 {
-    return Assert::assertInfinite(...\func_get_args());
+	return Assert::assertInfinite(...\func_get_args());
 }
 
 /**
@@ -807,7 +807,7 @@ 
  */
 function assertNan($actual, $message = '')
 {
-    return Assert::assertNan(...\func_get_args());
+	return Assert::assertNan(...\func_get_args());
 }
 
 /**
@@ -822,7 +822,7 @@ 
  */
 function assertNotContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
 {
-    return Assert::assertNotContains(...\func_get_args());
+	return Assert::assertNotContains(...\func_get_args());
 }
 
 /**
@@ -835,7 +835,7 @@ 
  */
 function assertNotContainsOnly($type, $haystack, $isNativeType = null, $message = '')
 {
-    return Assert::assertNotContainsOnly(...\func_get_args());
+	return Assert::assertNotContainsOnly(...\func_get_args());
 }
 
 /**
@@ -847,7 +847,7 @@ 
  */
 function assertNotCount($expectedCount, $haystack, $message = '')
 {
-    return Assert::assertNotCount(...\func_get_args());
+	return Assert::assertNotCount(...\func_get_args());
 }
 
 /**
@@ -860,7 +860,7 @@ 
  */
 function assertNotEmpty($actual, $message = '')
 {
-    return Assert::assertNotEmpty(...\func_get_args());
+	return Assert::assertNotEmpty(...\func_get_args());
 }
 
 /**
@@ -876,7 +876,7 @@ 
  */
 function assertNotEquals($expected, $actual, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::assertNotEquals(...\func_get_args());
+	return Assert::assertNotEquals(...\func_get_args());
 }
 
 /**
@@ -888,7 +888,7 @@ 
  */
 function assertNotInstanceOf($expected, $actual, $message = '')
 {
-    return Assert::assertNotInstanceOf(...\func_get_args());
+	return Assert::assertNotInstanceOf(...\func_get_args());
 }
 
 /**
@@ -900,7 +900,7 @@ 
  */
 function assertNotInternalType($expected, $actual, $message = '')
 {
-    return Assert::assertNotInternalType(...\func_get_args());
+	return Assert::assertNotInternalType(...\func_get_args());
 }
 
 /**
@@ -913,7 +913,7 @@ 
  */
 function assertNotFalse($condition, $message = '')
 {
-    return Assert::assertNotFalse(...\func_get_args());
+	return Assert::assertNotFalse(...\func_get_args());
 }
 
 /**
@@ -924,7 +924,7 @@ 
  */
 function assertNotNull($actual, $message = '')
 {
-    return Assert::assertNotNull(...\func_get_args());
+	return Assert::assertNotNull(...\func_get_args());
 }
 
 /**
@@ -936,7 +936,7 @@ 
  */
 function assertNotRegExp($pattern, $string, $message = '')
 {
-    return Assert::assertNotRegExp(...\func_get_args());
+	return Assert::assertNotRegExp(...\func_get_args());
 }
 
 /**
@@ -950,7 +950,7 @@ 
  */
 function assertNotSame($expected, $actual, $message = '')
 {
-    return Assert::assertNotSame(...\func_get_args());
+	return Assert::assertNotSame(...\func_get_args());
 }
 
 /**
@@ -963,7 +963,7 @@ 
  */
 function assertNotSameSize($expected, $actual, $message = '')
 {
-    return Assert::assertNotSameSize(...\func_get_args());
+	return Assert::assertNotSameSize(...\func_get_args());
 }
 
 /**
@@ -974,7 +974,7 @@ 
  */
 function assertNull($actual, $message = '')
 {
-    return Assert::assertNull(...\func_get_args());
+	return Assert::assertNull(...\func_get_args());
 }
 
 /**
@@ -986,7 +986,7 @@ 
  */
 function assertObjectHasAttribute($attributeName, $object, $message = '')
 {
-    return Assert::assertObjectHasAttribute(...\func_get_args());
+	return Assert::assertObjectHasAttribute(...\func_get_args());
 }
 
 /**
@@ -998,7 +998,7 @@ 
  */
 function assertObjectNotHasAttribute($attributeName, $object, $message = '')
 {
-    return Assert::assertObjectNotHasAttribute(...\func_get_args());
+	return Assert::assertObjectNotHasAttribute(...\func_get_args());
 }
 
 /**
@@ -1010,7 +1010,7 @@ 
  */
 function assertRegExp($pattern, $string, $message = '')
 {
-    return Assert::assertRegExp(...\func_get_args());
+	return Assert::assertRegExp(...\func_get_args());
 }
 
 /**
@@ -1024,7 +1024,7 @@ 
  */
 function assertSame($expected, $actual, $message = '')
 {
-    return Assert::assertSame(...\func_get_args());
+	return Assert::assertSame(...\func_get_args());
 }
 
 /**
@@ -1037,7 +1037,7 @@ 
  */
 function assertSameSize($expected, $actual, $message = '')
 {
-    return Assert::assertSameSize(...\func_get_args());
+	return Assert::assertSameSize(...\func_get_args());
 }
 
 /**
@@ -1049,7 +1049,7 @@ 
  */
 function assertStringEndsNotWith($suffix, $string, $message = '')
 {
-    return Assert::assertStringEndsNotWith(...\func_get_args());
+	return Assert::assertStringEndsNotWith(...\func_get_args());
 }
 
 /**
@@ -1061,7 +1061,7 @@ 
  */
 function assertStringEndsWith($suffix, $string, $message = '')
 {
-    return Assert::assertStringEndsWith(...\func_get_args());
+	return Assert::assertStringEndsWith(...\func_get_args());
 }
 
 /**
@@ -1076,7 +1076,7 @@ 
  */
 function assertStringEqualsFile($expectedFile, $actualString, $message = '', $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::assertStringEqualsFile(...\func_get_args());
+	return Assert::assertStringEqualsFile(...\func_get_args());
 }
 
 /**
@@ -1088,7 +1088,7 @@ 
  */
 function assertStringMatchesFormat($format, $string, $message = '')
 {
-    return Assert::assertStringMatchesFormat(...\func_get_args());
+	return Assert::assertStringMatchesFormat(...\func_get_args());
 }
 
 /**
@@ -1100,7 +1100,7 @@ 
  */
 function assertStringMatchesFormatFile($formatFile, $string, $message = '')
 {
-    return Assert::assertStringMatchesFormatFile(...\func_get_args());
+	return Assert::assertStringMatchesFormatFile(...\func_get_args());
 }
 
 /**
@@ -1115,7 +1115,7 @@ 
  */
 function assertStringNotEqualsFile($expectedFile, $actualString, $message = '', $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::assertStringNotEqualsFile(...\func_get_args());
+	return Assert::assertStringNotEqualsFile(...\func_get_args());
 }
 
 /**
@@ -1127,7 +1127,7 @@ 
  */
 function assertStringNotMatchesFormat($format, $string, $message = '')
 {
-    return Assert::assertStringNotMatchesFormat(...\func_get_args());
+	return Assert::assertStringNotMatchesFormat(...\func_get_args());
 }
 
 /**
@@ -1139,7 +1139,7 @@ 
  */
 function assertStringNotMatchesFormatFile($formatFile, $string, $message = '')
 {
-    return Assert::assertStringNotMatchesFormatFile(...\func_get_args());
+	return Assert::assertStringNotMatchesFormatFile(...\func_get_args());
 }
 
 /**
@@ -1151,7 +1151,7 @@ 
  */
 function assertStringStartsNotWith($prefix, $string, $message = '')
 {
-    return Assert::assertStringStartsNotWith(...\func_get_args());
+	return Assert::assertStringStartsNotWith(...\func_get_args());
 }
 
 /**
@@ -1163,7 +1163,7 @@ 
  */
 function assertStringStartsWith($prefix, $string, $message = '')
 {
-    return Assert::assertStringStartsWith(...\func_get_args());
+	return Assert::assertStringStartsWith(...\func_get_args());
 }
 
 /**
@@ -1175,7 +1175,7 @@ 
  */
 function assertThat($value, Constraint $constraint, $message = '')
 {
-    return Assert::assertThat(...\func_get_args());
+	return Assert::assertThat(...\func_get_args());
 }
 
 /**
@@ -1188,7 +1188,7 @@ 
  */
 function assertTrue($condition, $message = '')
 {
-    return Assert::assertTrue(...\func_get_args());
+	return Assert::assertTrue(...\func_get_args());
 }
 
 /**
@@ -1200,7 +1200,7 @@ 
  */
 function assertXmlFileEqualsXmlFile($expectedFile, $actualFile, $message = '')
 {
-    return Assert::assertXmlFileEqualsXmlFile(...\func_get_args());
+	return Assert::assertXmlFileEqualsXmlFile(...\func_get_args());
 }
 
 /**
@@ -1212,7 +1212,7 @@ 
  */
 function assertXmlFileNotEqualsXmlFile($expectedFile, $actualFile, $message = '')
 {
-    return Assert::assertXmlFileNotEqualsXmlFile(...\func_get_args());
+	return Assert::assertXmlFileNotEqualsXmlFile(...\func_get_args());
 }
 
 /**
@@ -1224,7 +1224,7 @@ 
  */
 function assertXmlStringEqualsXmlFile($expectedFile, $actualXml, $message = '')
 {
-    return Assert::assertXmlStringEqualsXmlFile(...\func_get_args());
+	return Assert::assertXmlStringEqualsXmlFile(...\func_get_args());
 }
 
 /**
@@ -1236,7 +1236,7 @@ 
  */
 function assertXmlStringEqualsXmlString($expectedXml, $actualXml, $message = '')
 {
-    return Assert::assertXmlStringEqualsXmlString(...\func_get_args());
+	return Assert::assertXmlStringEqualsXmlString(...\func_get_args());
 }
 
 /**
@@ -1248,7 +1248,7 @@ 
  */
 function assertXmlStringNotEqualsXmlFile($expectedFile, $actualXml, $message = '')
 {
-    return Assert::assertXmlStringNotEqualsXmlFile(...\func_get_args());
+	return Assert::assertXmlStringNotEqualsXmlFile(...\func_get_args());
 }
 
 /**
@@ -1260,7 +1260,7 @@ 
  */
 function assertXmlStringNotEqualsXmlString($expectedXml, $actualXml, $message = '')
 {
-    return Assert::assertXmlStringNotEqualsXmlString(...\func_get_args());
+	return Assert::assertXmlStringNotEqualsXmlString(...\func_get_args());
 }
 
 /**
@@ -1273,7 +1273,7 @@ 
  */
 function at($index)
 {
-    return TestCase::at(...\func_get_args());
+	return TestCase::at(...\func_get_args());
 }
 
 /**
@@ -1283,7 +1283,7 @@ 
  */
 function atLeastOnce()
 {
-    return TestCase::atLeastOnce();
+	return TestCase::atLeastOnce();
 }
 
 /**
@@ -1296,7 +1296,7 @@ 
  */
 function attribute(Constraint $constraint, $attributeName)
 {
-    return Assert::attribute(...\func_get_args());
+	return Assert::attribute(...\func_get_args());
 }
 
 /**
@@ -1315,7 +1315,7 @@ 
  */
 function attributeEqualTo($attributeName, $value, $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::attributeEqualTo(...\func_get_args());
+	return Assert::attributeEqualTo(...\func_get_args());
 }
 
 /**
@@ -1327,7 +1327,7 @@ 
  */
 function callback($callback)
 {
-    return Assert::callback(...\func_get_args());
+	return Assert::callback(...\func_get_args());
 }
 
 /**
@@ -1339,7 +1339,7 @@ 
  */
 function classHasAttribute($attributeName)
 {
-    return Assert::classHasAttribute(...\func_get_args());
+	return Assert::classHasAttribute(...\func_get_args());
 }
 
 /**
@@ -1352,7 +1352,7 @@ 
  */
 function classHasStaticAttribute($attributeName)
 {
-    return Assert::classHasStaticAttribute(...\func_get_args());
+	return Assert::classHasStaticAttribute(...\func_get_args());
 }
 
 /**
@@ -1367,7 +1367,7 @@ 
  */
 function contains($value, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
 {
-    return Assert::contains(...\func_get_args());
+	return Assert::contains(...\func_get_args());
 }
 
 /**
@@ -1380,7 +1380,7 @@ 
  */
 function containsOnly($type)
 {
-    return Assert::containsOnly(...\func_get_args());
+	return Assert::containsOnly(...\func_get_args());
 }
 
 /**
@@ -1393,7 +1393,7 @@ 
  */
 function containsOnlyInstancesOf($classname)
 {
-    return Assert::containsOnlyInstancesOf(...\func_get_args());
+	return Assert::containsOnlyInstancesOf(...\func_get_args());
 }
 
 /**
@@ -1405,7 +1405,7 @@ 
  */
 function countOf($count)
 {
-    return Assert::countOf(...\func_get_args());
+	return Assert::countOf(...\func_get_args());
 }
 
 /**
@@ -1415,7 +1415,7 @@ 
  */
 function directoryExists()
 {
-    return Assert::directoryExists();
+	return Assert::directoryExists();
 }
 
 /**
@@ -1431,7 +1431,7 @@ 
  */
 function equalTo($value, $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
 {
-    return Assert::equalTo(...\func_get_args());
+	return Assert::equalTo(...\func_get_args());
 }
 
 /**
@@ -1444,7 +1444,7 @@ 
  */
 function exactly($count)
 {
-    return TestCase::exactly(...\func_get_args());
+	return TestCase::exactly(...\func_get_args());
 }
 
 /**
@@ -1454,7 +1454,7 @@ 
  */
 function fileExists()
 {
-    return Assert::fileExists();
+	return Assert::fileExists();
 }
 
 /**
@@ -1466,7 +1466,7 @@ 
  */
 function greaterThan($value)
 {
-    return Assert::greaterThan(...\func_get_args());
+	return Assert::greaterThan(...\func_get_args());
 }
 
 /**
@@ -1480,7 +1480,7 @@ 
  */
 function greaterThanOrEqual($value)
 {
-    return Assert::greaterThanOrEqual(...\func_get_args());
+	return Assert::greaterThanOrEqual(...\func_get_args());
 }
 
 /**
@@ -1492,7 +1492,7 @@ 
  */
 function identicalTo($value)
 {
-    return Assert::identicalTo(...\func_get_args());
+	return Assert::identicalTo(...\func_get_args());
 }
 
 /**
@@ -1502,7 +1502,7 @@ 
  */
 function isEmpty()
 {
-    return Assert::isEmpty();
+	return Assert::isEmpty();
 }
 
 /**
@@ -1512,7 +1512,7 @@ 
  */
 function isFalse()
 {
-    return Assert::isFalse();
+	return Assert::isFalse();
 }
 
 /**
@@ -1522,7 +1522,7 @@ 
  */
 function isInfinite()
 {
-    return Assert::isInfinite();
+	return Assert::isInfinite();
 }
 
 /**
@@ -1534,7 +1534,7 @@ 
  */
 function isInstanceOf($className)
 {
-    return Assert::isInstanceOf(...\func_get_args());
+	return Assert::isInstanceOf(...\func_get_args());
 }
 
 /**
@@ -1544,7 +1544,7 @@ 
  */
 function isJson()
 {
-    return Assert::isJson();
+	return Assert::isJson();
 }
 
 /**
@@ -1554,7 +1554,7 @@ 
  */
 function isNan()
 {
-    return Assert::isNan();
+	return Assert::isNan();
 }
 
 /**
@@ -1564,7 +1564,7 @@ 
  */
 function isNull()
 {
-    return Assert::isNull();
+	return Assert::isNull();
 }
 
 /**
@@ -1574,7 +1574,7 @@ 
  */
 function isReadable()
 {
-    return Assert::isReadable();
+	return Assert::isReadable();
 }
 
 /**
@@ -1584,7 +1584,7 @@ 
  */
 function isTrue()
 {
-    return Assert::isTrue();
+	return Assert::isTrue();
 }
 
 /**
@@ -1596,7 +1596,7 @@ 
  */
 function isType($type)
 {
-    return Assert::isType(...\func_get_args());
+	return Assert::isType(...\func_get_args());
 }
 
 /**
@@ -1606,7 +1606,7 @@ 
  */
 function isWritable()
 {
-    return Assert::isWritable();
+	return Assert::isWritable();
 }
 
 /**
@@ -1618,7 +1618,7 @@ 
  */
 function lessThan($value)
 {
-    return Assert::lessThan(...\func_get_args());
+	return Assert::lessThan(...\func_get_args());
 }
 
 /**
@@ -1632,7 +1632,7 @@ 
  */
 function lessThanOrEqual($value)
 {
-    return Assert::lessThanOrEqual(...\func_get_args());
+	return Assert::lessThanOrEqual(...\func_get_args());
 }
 
 /**
@@ -1642,7 +1642,7 @@ 
  */
 function logicalAnd()
 {
-    return Assert::logicalAnd(...\func_get_args());
+	return Assert::logicalAnd(...\func_get_args());
 }
 
 /**
@@ -1654,7 +1654,7 @@ 
  */
 function logicalNot(Constraint $constraint)
 {
-    return Assert::logicalNot(...\func_get_args());
+	return Assert::logicalNot(...\func_get_args());
 }
 
 /**
@@ -1664,7 +1664,7 @@ 
  */
 function logicalOr()
 {
-    return Assert::logicalOr(...\func_get_args());
+	return Assert::logicalOr(...\func_get_args());
 }
 
 /**
@@ -1674,7 +1674,7 @@ 
  */
 function logicalXor()
 {
-    return Assert::logicalXor(...\func_get_args());
+	return Assert::logicalXor(...\func_get_args());
 }
 
 /**
@@ -1686,7 +1686,7 @@ 
  */
 function matches($string)
 {
-    return Assert::matches(...\func_get_args());
+	return Assert::matches(...\func_get_args());
 }
 
 /**
@@ -1698,7 +1698,7 @@ 
  */
 function matchesRegularExpression($pattern)
 {
-    return Assert::matchesRegularExpression(...\func_get_args());
+	return Assert::matchesRegularExpression(...\func_get_args());
 }
 
 /**
@@ -1708,7 +1708,7 @@ 
  */
 function never()
 {
-    return TestCase::never();
+	return TestCase::never();
 }
 
 /**
@@ -1720,7 +1720,7 @@ 
  */
 function objectHasAttribute($attributeName)
 {
-    return Assert::objectHasAttribute(...\func_get_args());
+	return Assert::objectHasAttribute(...\func_get_args());
 }
 
 /**
@@ -1730,7 +1730,7 @@ 
  */
 function onConsecutiveCalls()
 {
-    return TestCase::onConsecutiveCalls(...\func_get_args());
+	return TestCase::onConsecutiveCalls(...\func_get_args());
 }
 
 /**
@@ -1740,7 +1740,7 @@ 
  */
 function once()
 {
-    return TestCase::once();
+	return TestCase::once();
 }
 
 /**
@@ -1750,7 +1750,7 @@ 
  */
 function returnArgument($argumentIndex)
 {
-    return TestCase::returnArgument(...\func_get_args());
+	return TestCase::returnArgument(...\func_get_args());
 }
 
 /**
@@ -1760,7 +1760,7 @@ 
  */
 function returnCallback($callback)
 {
-    return TestCase::returnCallback(...\func_get_args());
+	return TestCase::returnCallback(...\func_get_args());
 }
 
 /**
@@ -1772,7 +1772,7 @@ 
  */
 function returnSelf()
 {
-    return TestCase::returnSelf();
+	return TestCase::returnSelf();
 }
 
 /**
@@ -1782,7 +1782,7 @@ 
  */
 function returnValue($value)
 {
-    return TestCase::returnValue(...\func_get_args());
+	return TestCase::returnValue(...\func_get_args());
 }
 
 /**
@@ -1792,7 +1792,7 @@ 
  */
 function returnValueMap(array $valueMap)
 {
-    return TestCase::returnValueMap(...\func_get_args());
+	return TestCase::returnValueMap(...\func_get_args());
 }
 
 /**
@@ -1805,7 +1805,7 @@ 
  */
 function stringContains($string, $case = true)
 {
-    return Assert::stringContains(...\func_get_args());
+	return Assert::stringContains(...\func_get_args());
 }
 
 /**
@@ -1817,7 +1817,7 @@ 
  */
 function stringEndsWith($suffix)
 {
-    return Assert::stringEndsWith(...\func_get_args());
+	return Assert::stringEndsWith(...\func_get_args());
 }
 
 /**
@@ -1829,7 +1829,7 @@ 
  */
 function stringStartsWith($prefix)
 {
-    return Assert::stringStartsWith(...\func_get_args());
+	return Assert::stringStartsWith(...\func_get_args());
 }
 
 /**
@@ -1839,5 +1839,5 @@ 
  */
 function throwException(Exception $exception)
 {
-    return TestCase::throwException(...\func_get_args());
+	return TestCase::throwException(...\func_get_args());
 }

vendor/phpunit/phpunit/src/Runner/BaseTestRunner.php

Indentation +123 added lines, -123 removed lines

@@ -21,127 +21,127 @@
  */
 abstract class BaseTestRunner
 {
-    const STATUS_PASSED     = 0;
-    const STATUS_SKIPPED    = 1;
-    const STATUS_INCOMPLETE = 2;
-    const STATUS_FAILURE    = 3;
-    const STATUS_ERROR      = 4;
-    const STATUS_RISKY      = 5;
-    const STATUS_WARNING    = 6;
-    const SUITE_METHODNAME  = 'suite';
-
-    /**
-     * Returns the loader to be used.
-     *
-     * @return TestSuiteLoader
-     */
-    public function getLoader()
-    {
-        return new StandardTestSuiteLoader;
-    }
-
-    /**
-     * Returns the Test corresponding to the given suite.
-     * This is a template method, subclasses override
-     * the runFailed() and clearStatus() methods.
-     *
-     * @param string $suiteClassName
-     * @param string $suiteClassFile
-     * @param mixed  $suffixes
-     *
-     * @return Test|null
-     */
-    public function getTest($suiteClassName, $suiteClassFile = '', $suffixes = '')
-    {
-        if (\is_dir($suiteClassName) &&
-            !\is_file($suiteClassName . '.php') && empty($suiteClassFile)) {
-            $facade = new File_Iterator_Facade;
-            $files  = $facade->getFilesAsArray(
-                $suiteClassName,
-                $suffixes
-            );
-
-            $suite = new TestSuite($suiteClassName);
-            $suite->addTestFiles($files);
-
-            return $suite;
-        }
-
-        try {
-            $testClass = $this->loadSuiteClass(
-                $suiteClassName,
-                $suiteClassFile
-            );
-        } catch (Exception $e) {
-            $this->runFailed($e->getMessage());
-
-            return;
-        }
-
-        try {
-            $suiteMethod = $testClass->getMethod(self::SUITE_METHODNAME);
-
-            if (!$suiteMethod->isStatic()) {
-                $this->runFailed(
-                    'suite() method must be static.'
-                );
-
-                return;
-            }
-
-            try {
-                $test = $suiteMethod->invoke(null, $testClass->getName());
-            } catch (ReflectionException $e) {
-                $this->runFailed(
-                    \sprintf(
-                        "Failed to invoke suite() method.\n%s",
-                        $e->getMessage()
-                    )
-                );
-
-                return;
-            }
-        } catch (ReflectionException $e) {
-            try {
-                $test = new TestSuite($testClass);
-            } catch (Exception $e) {
-                $test = new TestSuite;
-                $test->setName($suiteClassName);
-            }
-        }
-
-        $this->clearStatus();
-
-        return $test;
-    }
-
-    /**
-     * Returns the loaded ReflectionClass for a suite name.
-     *
-     * @param string $suiteClassName
-     * @param string $suiteClassFile
-     *
-     * @return ReflectionClass
-     */
-    protected function loadSuiteClass($suiteClassName, $suiteClassFile = '')
-    {
-        $loader = $this->getLoader();
-
-        return $loader->load($suiteClassName, $suiteClassFile);
-    }
-
-    /**
-     * Clears the status message.
-     */
-    protected function clearStatus()
-    {
-    }
-
-    /**
-     * Override to define how to handle a failed loading of
-     * a test suite.
-     *
-     * @param string $message
-     */
-    abstract protected function runFailed($message);
+	const STATUS_PASSED     = 0;
+	const STATUS_SKIPPED    = 1;
+	const STATUS_INCOMPLETE = 2;
+	const STATUS_FAILURE    = 3;
+	const STATUS_ERROR      = 4;
+	const STATUS_RISKY      = 5;
+	const STATUS_WARNING    = 6;
+	const SUITE_METHODNAME  = 'suite';
+
+	/**
+	 * Returns the loader to be used.
+	 *
+	 * @return TestSuiteLoader
+	 */
+	public function getLoader()
+	{
+		return new StandardTestSuiteLoader;
+	}
+
+	/**
+	 * Returns the Test corresponding to the given suite.
+	 * This is a template method, subclasses override
+	 * the runFailed() and clearStatus() methods.
+	 *
+	 * @param string $suiteClassName
+	 * @param string $suiteClassFile
+	 * @param mixed  $suffixes
+	 *
+	 * @return Test|null
+	 */
+	public function getTest($suiteClassName, $suiteClassFile = '', $suffixes = '')
+	{
+		if (\is_dir($suiteClassName) &&
+			!\is_file($suiteClassName . '.php') && empty($suiteClassFile)) {
+			$facade = new File_Iterator_Facade;
+			$files  = $facade->getFilesAsArray(
+				$suiteClassName,
+				$suffixes
+			);
+
+			$suite = new TestSuite($suiteClassName);
+			$suite->addTestFiles($files);
+
+			return $suite;
+		}
+
+		try {
+			$testClass = $this->loadSuiteClass(
+				$suiteClassName,
+				$suiteClassFile
+			);
+		} catch (Exception $e) {
+			$this->runFailed($e->getMessage());
+
+			return;
+		}
+
+		try {
+			$suiteMethod = $testClass->getMethod(self::SUITE_METHODNAME);
+
+			if (!$suiteMethod->isStatic()) {
+				$this->runFailed(
+					'suite() method must be static.'
+				);
+
+				return;
+			}
+
+			try {
+				$test = $suiteMethod->invoke(null, $testClass->getName());
+			} catch (ReflectionException $e) {
+				$this->runFailed(
+					\sprintf(
+						"Failed to invoke suite() method.\n%s",
+						$e->getMessage()
+					)
+				);
+
+				return;
+			}
+		} catch (ReflectionException $e) {
+			try {
+				$test = new TestSuite($testClass);
+			} catch (Exception $e) {
+				$test = new TestSuite;
+				$test->setName($suiteClassName);
+			}
+		}
+
+		$this->clearStatus();
+
+		return $test;
+	}
+
+	/**
+	 * Returns the loaded ReflectionClass for a suite name.
+	 *
+	 * @param string $suiteClassName
+	 * @param string $suiteClassFile
+	 *
+	 * @return ReflectionClass
+	 */
+	protected function loadSuiteClass($suiteClassName, $suiteClassFile = '')
+	{
+		$loader = $this->getLoader();
+
+		return $loader->load($suiteClassName, $suiteClassFile);
+	}
+
+	/**
+	 * Clears the status message.
+	 */
+	protected function clearStatus()
+	{
+	}
+
+	/**
+	 * Override to define how to handle a failed loading of
+	 * a test suite.
+	 *
+	 * @param string $message
+	 */
+	abstract protected function runFailed($message);
 }

Spacing +1 added lines, -1 removed lines

@@ -54,7 +54,7 @@
     public function getTest($suiteClassName, $suiteClassFile = '', $suffixes = '')
     {
         if (\is_dir($suiteClassName) &&
-            !\is_file($suiteClassName . '.php') && empty($suiteClassFile)) {
+            !\is_file($suiteClassName.'.php') && empty($suiteClassFile)) {
             $facade = new File_Iterator_Facade;
             $files  = $facade->getFilesAsArray(
                 $suiteClassName,

vendor/phpunit/phpunit/src/Runner/Version.php

Indentation +47 added lines, -47 removed lines

@@ -17,59 +17,59 @@
  */
 class Version
 {
-    private static $pharVersion;
-    private static $version;
+	private static $pharVersion;
+	private static $version;
 
-    /**
-     * Returns the current version of PHPUnit.
-     *
-     * @return string
-     */
-    public static function id()
-    {
-        if (self::$pharVersion !== null) {
-            return self::$pharVersion;
-        }
+	/**
+	 * Returns the current version of PHPUnit.
+	 *
+	 * @return string
+	 */
+	public static function id()
+	{
+		if (self::$pharVersion !== null) {
+			return self::$pharVersion;
+		}
 
-        if (self::$version === null) {
-            $version       = new VersionId('6.4.4', \dirname(\dirname(__DIR__)));
-            self::$version = $version->getVersion();
-        }
+		if (self::$version === null) {
+			$version       = new VersionId('6.4.4', \dirname(\dirname(__DIR__)));
+			self::$version = $version->getVersion();
+		}
 
-        return self::$version;
-    }
+		return self::$version;
+	}
 
-    /**
-     * @return string
-     */
-    public static function series()
-    {
-        if (\strpos(self::id(), '-')) {
-            $version = \explode('-', self::id())[0];
-        } else {
-            $version = self::id();
-        }
+	/**
+	 * @return string
+	 */
+	public static function series()
+	{
+		if (\strpos(self::id(), '-')) {
+			$version = \explode('-', self::id())[0];
+		} else {
+			$version = self::id();
+		}
 
-        return \implode('.', \array_slice(\explode('.', $version), 0, 2));
-    }
+		return \implode('.', \array_slice(\explode('.', $version), 0, 2));
+	}
 
-    /**
-     * @return string
-     */
-    public static function getVersionString()
-    {
-        return 'PHPUnit ' . self::id() . ' by Sebastian Bergmann and contributors.';
-    }
+	/**
+	 * @return string
+	 */
+	public static function getVersionString()
+	{
+		return 'PHPUnit ' . self::id() . ' by Sebastian Bergmann and contributors.';
+	}
 
-    /**
-     * @return string
-     */
-    public static function getReleaseChannel()
-    {
-        if (\strpos(self::$pharVersion, '-') !== false) {
-            return '-nightly';
-        }
+	/**
+	 * @return string
+	 */
+	public static function getReleaseChannel()
+	{
+		if (\strpos(self::$pharVersion, '-') !== false) {
+			return '-nightly';
+		}
 
-        return '';
-    }
+		return '';
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -58,7 +58,7 @@
      */
     public static function getVersionString()
     {
-        return 'PHPUnit ' . self::id() . ' by Sebastian Bergmann and contributors.';
+        return 'PHPUnit '.self::id().' by Sebastian Bergmann and contributors.';
     }
 
     /**

vendor/phpunit/phpunit/src/Runner/Filter/GroupFilterIterator.php

Indentation +43 added lines, -43 removed lines

@@ -15,47 +15,47 @@
 
 abstract class GroupFilterIterator extends RecursiveFilterIterator
 {
-    /**
-     * @var array
-     */
-    protected $groupTests = [];
-
-    /**
-     * @param RecursiveIterator $iterator
-     * @param array             $groups
-     * @param TestSuite         $suite
-     */
-    public function __construct(RecursiveIterator $iterator, array $groups, TestSuite $suite)
-    {
-        parent::__construct($iterator);
-
-        foreach ($suite->getGroupDetails() as $group => $tests) {
-            if (\in_array($group, $groups)) {
-                $testHashes = \array_map(
-                    function ($test) {
-                        return \spl_object_hash($test);
-                    },
-                    $tests
-                );
-
-                $this->groupTests = \array_merge($this->groupTests, $testHashes);
-            }
-        }
-    }
-
-    /**
-     * @return bool
-     */
-    public function accept()
-    {
-        $test = $this->getInnerIterator()->current();
-
-        if ($test instanceof TestSuite) {
-            return true;
-        }
-
-        return $this->doAccept(\spl_object_hash($test));
-    }
-
-    abstract protected function doAccept($hash);
+	/**
+	 * @var array
+	 */
+	protected $groupTests = [];
+
+	/**
+	 * @param RecursiveIterator $iterator
+	 * @param array             $groups
+	 * @param TestSuite         $suite
+	 */
+	public function __construct(RecursiveIterator $iterator, array $groups, TestSuite $suite)
+	{
+		parent::__construct($iterator);
+
+		foreach ($suite->getGroupDetails() as $group => $tests) {
+			if (\in_array($group, $groups)) {
+				$testHashes = \array_map(
+					function ($test) {
+						return \spl_object_hash($test);
+					},
+					$tests
+				);
+
+				$this->groupTests = \array_merge($this->groupTests, $testHashes);
+			}
+		}
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function accept()
+	{
+		$test = $this->getInnerIterator()->current();
+
+		if ($test instanceof TestSuite) {
+			return true;
+		}
+
+		return $this->doAccept(\spl_object_hash($test));
+	}
+
+	abstract protected function doAccept($hash);
 }

Spacing +1 added lines, -1 removed lines

@@ -32,7 +32,7 @@
         foreach ($suite->getGroupDetails() as $group => $tests) {
             if (\in_array($group, $groups)) {
                 $testHashes = \array_map(
-                    function ($test) {
+                    function($test) {
                         return \spl_object_hash($test);
                     },
                     $tests

vendor/phpunit/phpunit/src/Runner/Filter/Factory.php

Indentation +31 added lines, -31 removed lines

@@ -17,39 +17,39 @@
 
 class Factory
 {
-    /**
-     * @var array
-     */
-    private $filters = [];
+	/**
+	 * @var array
+	 */
+	private $filters = [];
 
-    /**
-     * @param ReflectionClass $filter
-     * @param mixed           $args
-     */
-    public function addFilter(ReflectionClass $filter, $args)
-    {
-        if (!$filter->isSubclassOf(\RecursiveFilterIterator::class)) {
-            throw new InvalidArgumentException(
-                \sprintf(
-                    'Class "%s" does not extend RecursiveFilterIterator',
-                    $filter->name
-                )
-            );
-        }
+	/**
+	 * @param ReflectionClass $filter
+	 * @param mixed           $args
+	 */
+	public function addFilter(ReflectionClass $filter, $args)
+	{
+		if (!$filter->isSubclassOf(\RecursiveFilterIterator::class)) {
+			throw new InvalidArgumentException(
+				\sprintf(
+					'Class "%s" does not extend RecursiveFilterIterator',
+					$filter->name
+				)
+			);
+		}
 
-        $this->filters[] = [$filter, $args];
-    }
+		$this->filters[] = [$filter, $args];
+	}
 
-    /**
-     * @return FilterIterator
-     */
-    public function factory(Iterator $iterator, TestSuite $suite)
-    {
-        foreach ($this->filters as $filter) {
-            list($class, $args) = $filter;
-            $iterator           = $class->newInstance($iterator, $args, $suite);
-        }
+	/**
+	 * @return FilterIterator
+	 */
+	public function factory(Iterator $iterator, TestSuite $suite)
+	{
+		foreach ($this->filters as $filter) {
+			list($class, $args) = $filter;
+			$iterator           = $class->newInstance($iterator, $args, $suite);
+		}
 
-        return $iterator;
-    }
+		return $iterator;
+	}
 }

vendor/phpunit/phpunit/src/Runner/Filter/IncludeGroupFilterIterator.php

Indentation +9 added lines, -9 removed lines

@@ -11,13 +11,13 @@
 
 class IncludeGroupFilterIterator extends GroupFilterIterator
 {
-    /**
-     * @param string $hash
-     *
-     * @return bool
-     */
-    protected function doAccept($hash)
-    {
-        return \in_array($hash, $this->groupTests);
-    }
+	/**
+	 * @param string $hash
+	 *
+	 * @return bool
+	 */
+	protected function doAccept($hash)
+	{
+		return \in_array($hash, $this->groupTests);
+	}
 }

vendor/phpunit/phpunit/src/Runner/Filter/NameFilterIterator.php

Indentation +91 added lines, -91 removed lines

@@ -17,108 +17,108 @@
 
 class NameFilterIterator extends RecursiveFilterIterator
 {
-    /**
-     * @var string
-     */
-    protected $filter;
+	/**
+	 * @var string
+	 */
+	protected $filter;
 
-    /**
-     * @var int
-     */
-    protected $filterMin;
-    /**
-     * @var int
-     */
-    protected $filterMax;
+	/**
+	 * @var int
+	 */
+	protected $filterMin;
+	/**
+	 * @var int
+	 */
+	protected $filterMax;
 
-    /**
-     * @param RecursiveIterator $iterator
-     * @param string            $filter
-     */
-    public function __construct(RecursiveIterator $iterator, $filter)
-    {
-        parent::__construct($iterator);
-        $this->setFilter($filter);
-    }
+	/**
+	 * @param RecursiveIterator $iterator
+	 * @param string            $filter
+	 */
+	public function __construct(RecursiveIterator $iterator, $filter)
+	{
+		parent::__construct($iterator);
+		$this->setFilter($filter);
+	}
 
-    /**
-     * @param string $filter
-     */
-    protected function setFilter($filter)
-    {
-        if (RegularExpression::safeMatch($filter, '') === false) {
-            // Handles:
-            //  * testAssertEqualsSucceeds#4
-            //  * testAssertEqualsSucceeds#4-8
-            if (\preg_match('/^(.*?)#(\d+)(?:-(\d+))?$/', $filter, $matches)) {
-                if (isset($matches[3]) && $matches[2] < $matches[3]) {
-                    $filter = \sprintf(
-                        '%s.*with data set #(\d+)$',
-                        $matches[1]
-                    );
+	/**
+	 * @param string $filter
+	 */
+	protected function setFilter($filter)
+	{
+		if (RegularExpression::safeMatch($filter, '') === false) {
+			// Handles:
+			//  * testAssertEqualsSucceeds#4
+			//  * testAssertEqualsSucceeds#4-8
+			if (\preg_match('/^(.*?)#(\d+)(?:-(\d+))?$/', $filter, $matches)) {
+				if (isset($matches[3]) && $matches[2] < $matches[3]) {
+					$filter = \sprintf(
+						'%s.*with data set #(\d+)$',
+						$matches[1]
+					);
 
-                    $this->filterMin = $matches[2];
-                    $this->filterMax = $matches[3];
-                } else {
-                    $filter = \sprintf(
-                        '%s.*with data set #%s$',
-                        $matches[1],
-                        $matches[2]
-                    );
-                }
-            } // Handles:
-            //  * testDetermineJsonError@JSON_ERROR_NONE
-            //  * testDetermineJsonError@JSON.*
-            elseif (\preg_match('/^(.*?)@(.+)$/', $filter, $matches)) {
-                $filter = \sprintf(
-                    '%s.*with data set "%s"$',
-                    $matches[1],
-                    $matches[2]
-                );
-            }
+					$this->filterMin = $matches[2];
+					$this->filterMax = $matches[3];
+				} else {
+					$filter = \sprintf(
+						'%s.*with data set #%s$',
+						$matches[1],
+						$matches[2]
+					);
+				}
+			} // Handles:
+			//  * testDetermineJsonError@JSON_ERROR_NONE
+			//  * testDetermineJsonError@JSON.*
+			elseif (\preg_match('/^(.*?)@(.+)$/', $filter, $matches)) {
+				$filter = \sprintf(
+					'%s.*with data set "%s"$',
+					$matches[1],
+					$matches[2]
+				);
+			}
 
-            // Escape delimiters in regular expression. Do NOT use preg_quote,
-            // to keep magic characters.
-            $filter = \sprintf('/%s/', \str_replace(
-                '/',
-                '\\/',
-                $filter
-            ));
-        }
+			// Escape delimiters in regular expression. Do NOT use preg_quote,
+			// to keep magic characters.
+			$filter = \sprintf('/%s/', \str_replace(
+				'/',
+				'\\/',
+				$filter
+			));
+		}
 
-        $this->filter = $filter;
-    }
+		$this->filter = $filter;
+	}
 
-    /**
-     * @return bool
-     */
-    public function accept()
-    {
-        $test = $this->getInnerIterator()->current();
+	/**
+	 * @return bool
+	 */
+	public function accept()
+	{
+		$test = $this->getInnerIterator()->current();
 
-        if ($test instanceof TestSuite) {
-            return true;
-        }
+		if ($test instanceof TestSuite) {
+			return true;
+		}
 
-        $tmp = \PHPUnit\Util\Test::describe($test, false);
+		$tmp = \PHPUnit\Util\Test::describe($test, false);
 
-        if ($test instanceof WarningTestCase) {
-            $name = $test->getMessage();
-        } else {
-            if ($tmp[0] != '') {
-                $name = \implode('::', $tmp);
-            } else {
-                $name = $tmp[1];
-            }
-        }
+		if ($test instanceof WarningTestCase) {
+			$name = $test->getMessage();
+		} else {
+			if ($tmp[0] != '') {
+				$name = \implode('::', $tmp);
+			} else {
+				$name = $tmp[1];
+			}
+		}
 
-        $accepted = @\preg_match($this->filter, $name, $matches);
+		$accepted = @\preg_match($this->filter, $name, $matches);
 
-        if ($accepted && isset($this->filterMax)) {
-            $set      = \end($matches);
-            $accepted = $set >= $this->filterMin && $set <= $this->filterMax;
-        }
+		if ($accepted && isset($this->filterMax)) {
+			$set      = \end($matches);
+			$accepted = $set >= $this->filterMin && $set <= $this->filterMax;
+		}
 
-        return $accepted;
-    }
+		return $accepted;
+	}
 }

vendor/phpunit/phpunit/src/Runner/Filter/ExcludeGroupFilterIterator.php

Indentation +9 added lines, -9 removed lines

@@ -11,13 +11,13 @@
 
 class ExcludeGroupFilterIterator extends GroupFilterIterator
 {
-    /**
-     * @param string $hash
-     *
-     * @return bool
-     */
-    protected function doAccept($hash)
-    {
-        return !\in_array($hash, $this->groupTests);
-    }
+	/**
+	 * @param string $hash
+	 *
+	 * @return bool
+	 */
+	protected function doAccept($hash)
+	{
+		return !\in_array($hash, $this->groupTests);
+	}
 }