Framework_TestCaseTest

Complexity

Total Complexity

43

Size/Duplication

Total Lines	523
Duplicated Lines	48.37 %

Coupling/Cohesion

Components	2
Dependencies	22

43 Methods

Rating	Name	Duplication	Size	Complexity
A	testCaseToString()	0	7	1
A	testSuccess()	11	11	1
A	testFailure()	11	11	1
A	testError()	11	11	1
A	testSkipped()	12	12	1
A	testIncomplete()	12	12	1
A	testExceptionInSetUp()	11	11	1
A	testExceptionInAssertPreConditions()	11	11	1
A	testExceptionInTest()	11	11	1
A	testExceptionInAssertPostConditions()	11	11	1
A	testExceptionInTearDown()	11	11	1
A	testNoArgTestCasePasses()	0	11	1
A	testWasRun()	0	7	1
A	testException()	0	10	1
A	testExceptionWithMessage()	0	10	1
A	testExceptionWithWrongMessage()	14	14	1
A	testExceptionWithRegexpMessage()	0	10	1
A	testExceptionWithWrongRegexpMessage()	14	14	1
A	testExceptionWithInvalidRegexpMessage()	0	12	1
A	testNoException()	10	10	1
A	testWrongException()	10	10	1
B	testGlobalsBackupPre()	0	41	1
A	testGlobalsBackupPost()	0	19	1
A	testStaticAttributesBackupPre()	0	5	1
A	testStaticAttributesBackupPost()	0	5	1
A	testIsInIsolationReturnsFalse()	8	8	1
A	testIsInIsolationReturnsTrue()	9	9	1
A	testExpectOutputStringFooActualFoo()	8	8	1
A	testExpectOutputStringFooActualBar()	8	8	1
A	testExpectOutputRegexFooActualFoo()	8	8	1
A	testExpectOutputRegexFooActualBar()	8	8	1
A	testSkipsIfRequiresHigherVersionOfPHPUnit()	11	11	1
A	testSkipsIfRequiresHigherVersionOfPHP()	11	11	1
A	testSkipsIfRequiresNonExistingOs()	11	11	1
A	testSkipsIfRequiresNonExistingFunction()	11	11	1
A	testSkipsIfRequiresNonExistingExtension()	0	10	1
A	testSkipsProvidesMessagesForAllSkippingReasons()	0	16	1
A	testRequiringAnExistingMethodDoesNotSkip()	0	6	1
A	testRequiringAnExistingFunctionDoesNotSkip()	0	6	1
A	testRequiringAnExistingExtensionDoesNotSkip()	0	6	1
A	testRequiringAnExistingOsDoesNotSkip()	0	6	1
A	testCurrentWorkingDirectoryIsRestored()	0	9	1
A	testTypeErrorCanBeExpected()	0	5	1

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 28 and the first side effect is on line 11.

/*
 * This file is part of PHPUnit.
 *
 * (c) Sebastian Bergmann <sebastian@phpunit.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'NoArgTestCaseTest.php';
require_once dirname(__DIR__) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'Singleton.php';

$GLOBALS['a']  = 'a';
$_ENV['b']     = 'b';
$_POST['c']    = 'c';
$_GET['d']     = 'd';
$_COOKIE['e']  = 'e';
$_SERVER['f']  = 'f';
$_FILES['g']   = 'g';
$_REQUEST['h'] = 'h';
$GLOBALS['i']  = 'i';

/**
 * @since      Class available since Release 2.0.0
 * @covers     PHPUnit_Framework_TestCase
 */
class Framework_TestCaseTest extends PHPUnit_Framework_TestCase

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    protected $backupGlobalsBlacklist = array('i', 'singleton');

    /**
     * Used be testStaticAttributesBackupPre
     */
    protected static $_testStatic = 0;

    public function testCaseToString()
    {
        $this->assertEquals(
            'Framework_TestCaseTest::testCaseToString',
            $this->toString()
        );
    }

    public function testSuccess()

This method seems to be duplicated in your project.

    {
        $test   = new Success;
        $result = $test->run();

        $this->assertEquals(PHPUnit_Runner_BaseTestRunner::STATUS_PASSED, $test->getStatus());
        $this->assertEquals(0, $result->errorCount());
        $this->assertEquals(0, $result->failureCount());
        $this->assertEquals(0, $result->skippedCount());
        $this->assertEquals(1, count($result));
    }

    public function testFailure()

This method seems to be duplicated in your project.

    {
        $test   = new Failure;
        $result = $test->run();

        $this->assertEquals(PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE, $test->getStatus());
        $this->assertEquals(0, $result->errorCount());
        $this->assertEquals(1, $result->failureCount());
        $this->assertEquals(0, $result->skippedCount());
        $this->assertEquals(1, count($result));
    }

    public function testError()

This method seems to be duplicated in your project.

    {
        $test   = new TestError;
        $result = $test->run();

        $this->assertEquals(PHPUnit_Runner_BaseTestRunner::STATUS_ERROR, $test->getStatus());
        $this->assertEquals(1, $result->errorCount());
        $this->assertEquals(0, $result->failureCount());
        $this->assertEquals(0, $result->skippedCount());
        $this->assertEquals(1, count($result));
    }

    public function testSkipped()

This method seems to be duplicated in your project.

    {
        $test   = new TestSkipped();
        $result = $test->run();

        $this->assertEquals(PHPUnit_Runner_BaseTestRunner::STATUS_SKIPPED, $test->getStatus());
        $this->assertEquals('Skipped test', $test->getStatusMessage());
        $this->assertEquals(0, $result->errorCount());
        $this->assertEquals(0, $result->failureCount());
        $this->assertEquals(1, $result->skippedCount());
        $this->assertEquals(1, count($result));
    }

    public function testIncomplete()

This method seems to be duplicated in your project.

    {
        $test   = new TestIncomplete();
        $result = $test->run();

        $this->assertEquals(PHPUnit_Runner_BaseTestRunner::STATUS_INCOMPLETE, $test->getStatus());
        $this->assertEquals('Incomplete test', $test->getStatusMessage());
        $this->assertEquals(0, $result->errorCount());
        $this->assertEquals(0, $result->failureCount());
        $this->assertEquals(0, $result->skippedCount());
        $this->assertEquals(1, count($result));
    }

    public function testExceptionInSetUp()

This method seems to be duplicated in your project.

    {
        $test   = new ExceptionInSetUpTest('testSomething');
        $result = $test->run();

$result is not used, you could remove the assignment.

        $this->assertTrue($test->setUp);
        $this->assertFalse($test->assertPreConditions);
        $this->assertFalse($test->testSomething);
        $this->assertFalse($test->assertPostConditions);
        $this->assertTrue($test->tearDown);
    }

    public function testExceptionInAssertPreConditions()

This method seems to be duplicated in your project.

    {
        $test   = new ExceptionInAssertPreConditionsTest('testSomething');
        $result = $test->run();

$result is not used, you could remove the assignment.

        $this->assertTrue($test->setUp);
        $this->assertTrue($test->assertPreConditions);
        $this->assertFalse($test->testSomething);
        $this->assertFalse($test->assertPostConditions);
        $this->assertTrue($test->tearDown);
    }

    public function testExceptionInTest()

This method seems to be duplicated in your project.

    {
        $test   = new ExceptionInTest('testSomething');
        $result = $test->run();

$result is not used, you could remove the assignment.

        $this->assertTrue($test->setUp);
        $this->assertTrue($test->assertPreConditions);
        $this->assertTrue($test->testSomething);
        $this->assertFalse($test->assertPostConditions);
        $this->assertTrue($test->tearDown);
    }

    public function testExceptionInAssertPostConditions()

This method seems to be duplicated in your project.

    {
        $test   = new ExceptionInAssertPostConditionsTest('testSomething');
        $result = $test->run();

$result is not used, you could remove the assignment.

        $this->assertTrue($test->setUp);
        $this->assertTrue($test->assertPreConditions);
        $this->assertTrue($test->testSomething);
        $this->assertTrue($test->assertPostConditions);
        $this->assertTrue($test->tearDown);
    }

    public function testExceptionInTearDown()

This method seems to be duplicated in your project.

    {
        $test   = new ExceptionInTearDownTest('testSomething');
        $result = $test->run();

$result is not used, you could remove the assignment.

        $this->assertTrue($test->setUp);
        $this->assertTrue($test->assertPreConditions);
        $this->assertTrue($test->testSomething);
        $this->assertTrue($test->assertPostConditions);
        $this->assertTrue($test->tearDown);
    }

    public function testNoArgTestCasePasses()
    {
        $result = new PHPUnit_Framework_TestResult;
        $t      = new PHPUnit_Framework_TestSuite('NoArgTestCaseTest');

        $t->run($result);

        $this->assertEquals(1, count($result));
        $this->assertEquals(0, $result->failureCount());
        $this->assertEquals(0, $result->errorCount());
    }

    public function testWasRun()
    {
        $test = new WasRun;
        $test->run();

        $this->assertTrue($test->wasRun);
    }

    public function testException()
    {
        $test = new ThrowExceptionTestCase('test');
        $test->setExpectedException('RuntimeException');

        $result = $test->run();

        $this->assertEquals(1, count($result));
        $this->assertTrue($result->wasSuccessful());
    }

    public function testExceptionWithMessage()
    {
        $test = new ThrowExceptionTestCase('test');
        $test->setExpectedException('RuntimeException', 'A runtime error occurred');

        $result = $test->run();

        $this->assertEquals(1, count($result));
        $this->assertTrue($result->wasSuccessful());
    }

    public function testExceptionWithWrongMessage()

This method seems to be duplicated in your project.

    {
        $test = new ThrowExceptionTestCase('test');
        $test->setExpectedException('RuntimeException', 'A logic error occurred');

        $result = $test->run();

        $this->assertEquals(1, $result->failureCount());
        $this->assertEquals(1, count($result));
        $this->assertEquals(
            "Failed asserting that exception message 'A runtime error occurred' contains 'A logic error occurred'.",
            $test->getStatusMessage()
        );
    }

    public function testExceptionWithRegexpMessage()
    {
        $test = new ThrowExceptionTestCase('test');
        $test->setExpectedExceptionRegExp('RuntimeException', '/runtime .*? occurred/');

        $result = $test->run();

        $this->assertEquals(1, count($result));
        $this->assertTrue($result->wasSuccessful());
    }

    public function testExceptionWithWrongRegexpMessage()

This method seems to be duplicated in your project.

    {
        $test = new ThrowExceptionTestCase('test');
        $test->setExpectedExceptionRegExp('RuntimeException', '/logic .*? occurred/');

        $result = $test->run();

        $this->assertEquals(1, $result->failureCount());
        $this->assertEquals(1, count($result));
        $this->assertEquals(
            "Failed asserting that exception message 'A runtime error occurred' matches '/logic .*? occurred/'.",
            $test->getStatusMessage()
        );
    }

    /**
     * @covers PHPUnit_Framework_Constraint_ExceptionMessageRegExp
     */
    public function testExceptionWithInvalidRegexpMessage()
    {
        $test = new ThrowExceptionTestCase('test');
        $test->setExpectedExceptionRegExp('RuntimeException', '#runtime .*? occurred/'); // wrong delimiter

        $result = $test->run();

$result is not used, you could remove the assignment.

        $this->assertEquals(
            "Invalid expected exception message regex given: '#runtime .*? occurred/'",
            $test->getStatusMessage()
        );
    }

    public function testNoException()

This method seems to be duplicated in your project.

    {
        $test = new ThrowNoExceptionTestCase('test');
        $test->setExpectedException('RuntimeException');

        $result = $test->run();

        $this->assertEquals(1, $result->failureCount());
        $this->assertEquals(1, count($result));
    }

    public function testWrongException()

This method seems to be duplicated in your project.

    {
        $test = new ThrowExceptionTestCase('test');
        $test->setExpectedException('InvalidArgumentException');

        $result = $test->run();

        $this->assertEquals(1, $result->failureCount());
        $this->assertEquals(1, count($result));
    }

    /**
     * @backupGlobals enabled
     */
    public function testGlobalsBackupPre()

testGlobalsBackupPre uses the super-global variable $GLOBALS which is generally not recommended.

testGlobalsBackupPre uses the super-global variable $_ENV which is generally not recommended.

testGlobalsBackupPre uses the super-global variable $_POST which is generally not recommended.

testGlobalsBackupPre uses the super-global variable $_GET which is generally not recommended.

testGlobalsBackupPre uses the super-global variable $_COOKIE which is generally not recommended.

testGlobalsBackupPre uses the super-global variable $_SERVER which is generally not recommended.

testGlobalsBackupPre uses the super-global variable $_FILES which is generally not recommended.

testGlobalsBackupPre uses the super-global variable $_REQUEST which is generally not recommended.

    {
        global $a;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        global $i;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        $this->assertEquals('a', $a);
        $this->assertEquals('a', $GLOBALS['a']);
        $this->assertEquals('b', $_ENV['b']);
        $this->assertEquals('c', $_POST['c']);
        $this->assertEquals('d', $_GET['d']);
        $this->assertEquals('e', $_COOKIE['e']);
        $this->assertEquals('f', $_SERVER['f']);
        $this->assertEquals('g', $_FILES['g']);
        $this->assertEquals('h', $_REQUEST['h']);
        $this->assertEquals('i', $i);
        $this->assertEquals('i', $GLOBALS['i']);

        $GLOBALS['a']   = 'aa';
        $GLOBALS['foo'] = 'bar';
        $_ENV['b']      = 'bb';
        $_POST['c']     = 'cc';
        $_GET['d']      = 'dd';
        $_COOKIE['e']   = 'ee';
        $_SERVER['f']   = 'ff';
        $_FILES['g']    = 'gg';
        $_REQUEST['h']  = 'hh';
        $GLOBALS['i']   = 'ii';

        $this->assertEquals('aa', $a);
        $this->assertEquals('aa', $GLOBALS['a']);
        $this->assertEquals('bar', $GLOBALS['foo']);
        $this->assertEquals('bb', $_ENV['b']);
        $this->assertEquals('cc', $_POST['c']);
        $this->assertEquals('dd', $_GET['d']);
        $this->assertEquals('ee', $_COOKIE['e']);
        $this->assertEquals('ff', $_SERVER['f']);
        $this->assertEquals('gg', $_FILES['g']);
        $this->assertEquals('hh', $_REQUEST['h']);
        $this->assertEquals('ii', $i);
        $this->assertEquals('ii', $GLOBALS['i']);
    }

    public function testGlobalsBackupPost()

testGlobalsBackupPost uses the super-global variable $GLOBALS which is generally not recommended.

testGlobalsBackupPost uses the super-global variable $_ENV which is generally not recommended.

testGlobalsBackupPost uses the super-global variable $_POST which is generally not recommended.

testGlobalsBackupPost uses the super-global variable $_GET which is generally not recommended.

testGlobalsBackupPost uses the super-global variable $_COOKIE which is generally not recommended.

testGlobalsBackupPost uses the super-global variable $_SERVER which is generally not recommended.

testGlobalsBackupPost uses the super-global variable $_FILES which is generally not recommended.

testGlobalsBackupPost uses the super-global variable $_REQUEST which is generally not recommended.

    {
        global $a;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        global $i;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        $this->assertEquals('a', $a);
        $this->assertEquals('a', $GLOBALS['a']);
        $this->assertEquals('b', $_ENV['b']);
        $this->assertEquals('c', $_POST['c']);
        $this->assertEquals('d', $_GET['d']);
        $this->assertEquals('e', $_COOKIE['e']);
        $this->assertEquals('f', $_SERVER['f']);
        $this->assertEquals('g', $_FILES['g']);
        $this->assertEquals('h', $_REQUEST['h']);
        $this->assertEquals('ii', $i);
        $this->assertEquals('ii', $GLOBALS['i']);

        $this->assertArrayNotHasKey('foo', $GLOBALS);
    }

    /**
     * @backupGlobals enabled
     * @backupStaticAttributes enabled
     */
    public function testStaticAttributesBackupPre()

testStaticAttributesBackupPre uses the super-global variable $GLOBALS which is generally not recommended.

    {
        $GLOBALS['singleton'] = Singleton::getInstance();
        self::$_testStatic    = 123;
    }

    /**
     * @depends testStaticAttributesBackupPre
     */
    public function testStaticAttributesBackupPost()

testStaticAttributesBackupPost uses the super-global variable $GLOBALS which is generally not recommended.

    {
        $this->assertNotSame($GLOBALS['singleton'], Singleton::getInstance());
        $this->assertSame(0, self::$_testStatic);
    }

    public function testIsInIsolationReturnsFalse()

This method seems to be duplicated in your project.

    {
        $test   = new IsolationTest('testIsInIsolationReturnsFalse');
        $result = $test->run();

        $this->assertEquals(1, count($result));
        $this->assertTrue($result->wasSuccessful());
    }

    public function testIsInIsolationReturnsTrue()

This method seems to be duplicated in your project.

    {
        $test   = new IsolationTest('testIsInIsolationReturnsTrue');
        $test->setRunTestInSeparateProcess(true);
        $result = $test->run();

        $this->assertEquals(1, count($result));
        $this->assertTrue($result->wasSuccessful());
    }

    public function testExpectOutputStringFooActualFoo()

This method seems to be duplicated in your project.

    {
        $test   = new OutputTestCase('testExpectOutputStringFooActualFoo');
        $result = $test->run();

        $this->assertEquals(1, count($result));
        $this->assertTrue($result->wasSuccessful());
    }

    public function testExpectOutputStringFooActualBar()

This method seems to be duplicated in your project.

    {
        $test   = new OutputTestCase('testExpectOutputStringFooActualBar');
        $result = $test->run();

        $this->assertEquals(1, count($result));
        $this->assertFalse($result->wasSuccessful());
    }

    public function testExpectOutputRegexFooActualFoo()

This method seems to be duplicated in your project.

    {
        $test   = new OutputTestCase('testExpectOutputRegexFooActualFoo');
        $result = $test->run();

        $this->assertEquals(1, count($result));
        $this->assertTrue($result->wasSuccessful());
    }

    public function testExpectOutputRegexFooActualBar()

This method seems to be duplicated in your project.

    {
        $test   = new OutputTestCase('testExpectOutputRegexFooActualBar');
        $result = $test->run();

        $this->assertEquals(1, count($result));
        $this->assertFalse($result->wasSuccessful());
    }

    public function testSkipsIfRequiresHigherVersionOfPHPUnit()

This method seems to be duplicated in your project.

    {
        $test   = new RequirementsTest('testAlwaysSkip');
        $result = $test->run();

        $this->assertEquals(1, $result->skippedCount());
        $this->assertEquals(
            'PHPUnit 1111111 (or later) is required.',
            $test->getStatusMessage()
        );
    }

    public function testSkipsIfRequiresHigherVersionOfPHP()

This method seems to be duplicated in your project.

    {
        $test   = new RequirementsTest('testAlwaysSkip2');
        $result = $test->run();

        $this->assertEquals(1, $result->skippedCount());
        $this->assertEquals(
            'PHP 9999999 (or later) is required.',
            $test->getStatusMessage()
        );
    }

    public function testSkipsIfRequiresNonExistingOs()

This method seems to be duplicated in your project.

    {
        $test   = new RequirementsTest('testAlwaysSkip3');
        $result = $test->run();

        $this->assertEquals(1, $result->skippedCount());
        $this->assertEquals(
            'Operating system matching /DOESNOTEXIST/i is required.',
            $test->getStatusMessage()
        );
    }

    public function testSkipsIfRequiresNonExistingFunction()

This method seems to be duplicated in your project.

    {
        $test   = new RequirementsTest('testNine');
        $result = $test->run();

        $this->assertEquals(1, $result->skippedCount());
        $this->assertEquals(
            'Function testFunc is required.',
            $test->getStatusMessage()
        );
    }

    public function testSkipsIfRequiresNonExistingExtension()
    {
        $test   = new RequirementsTest('testTen');
        $result = $test->run();

$result is not used, you could remove the assignment.

        $this->assertEquals(
            'Extension testExt is required.',
            $test->getStatusMessage()
        );
    }

    public function testSkipsProvidesMessagesForAllSkippingReasons()
    {
        $test   = new RequirementsTest('testAllPossibleRequirements');
        $result = $test->run();

$result is not used, you could remove the assignment.

        $this->assertEquals(
            'PHP 99-dev (or later) is required.' . PHP_EOL .
            'PHPUnit 9-dev (or later) is required.' . PHP_EOL .
            'Operating system matching /DOESNOTEXIST/i is required.' . PHP_EOL .
            'Function testFuncOne is required.' . PHP_EOL .
            'Function testFuncTwo is required.' . PHP_EOL .
            'Extension testExtOne is required.' . PHP_EOL .
            'Extension testExtTwo is required.',
            $test->getStatusMessage()
        );
    }

    public function testRequiringAnExistingMethodDoesNotSkip()
    {
        $test   = new RequirementsTest('testExistingMethod');
        $result = $test->run();
        $this->assertEquals(0, $result->skippedCount());
    }

    public function testRequiringAnExistingFunctionDoesNotSkip()
    {
        $test   = new RequirementsTest('testExistingFunction');
        $result = $test->run();
        $this->assertEquals(0, $result->skippedCount());
    }

    public function testRequiringAnExistingExtensionDoesNotSkip()
    {
        $test   = new RequirementsTest('testExistingExtension');
        $result = $test->run();
        $this->assertEquals(0, $result->skippedCount());
    }

    public function testRequiringAnExistingOsDoesNotSkip()
    {
        $test   = new RequirementsTest('testExistingOs');
        $result = $test->run();
        $this->assertEquals(0, $result->skippedCount());
    }

    public function testCurrentWorkingDirectoryIsRestored()
    {
        $expectedCwd = getcwd();

        $test = new ChangeCurrentWorkingDirectoryTest('testSomethingThatChangesTheCwd');
        $test->run();

        $this->assertSame($expectedCwd, getcwd());
    }

    /**
     * @requires PHP 7
     * @expectedException TypeError
     */
    public function testTypeErrorCanBeExpected()
    {
        $o = new ClassWithScalarTypeDeclarations;
        $o->foo(null, null);
    }
}