/** * @dataProvider handlerProvider */ public function testManufactureHandlers($types, $options) { $handler = HandlerFactory::createHandler($types, $options); if (count($types) > 1) { $handlerclass = $this->handlers['Composite']; $h = \PHPUnit_Util_Class::getObjectAttribute($handler, 'drivers'); $handlers = array_combine($types, $h); } else { $handlerclass = $this->handlers[$types[0]]; $handlers = array($types[0] => $handler); } $this->assertInstanceOf($handlerclass, $handler); foreach ($handlers as $subtype => $subhandler) { $subhandlerclass = $this->handlers[$subtype]; $this->assertInstanceOf($subhandlerclass, $subhandler); } foreach ($types as $type) { $defaults = isset($this->defaultSettings[$type]) ? $this->defaultSettings[$type] : array(); $options = array_merge($defaults, $options); /* foreach($options as $optname => $optvalue) { $this->assertAttributeEquals($optvalue, $optname, $handlers[$type]); } */ } }
/** * Test that if a dynamic variable is defined on a class then * the $attribute variable will be NULL, but the variable defined * will be a public one so we are safe to return it * * Currently $attribute is NULL but we try and call isPublic() on it. * This breaks for php 5.2.10 * * @covers PHPUnit_Util_Class::getObjectAttribute * * @return void */ public function testGetObjectAttributeCanHandleDynamicVariables() { $attributeName = '_variable'; $object = new stdClass(); $object->{$attributeName} = 'Test'; $actual = PHPUnit_Util_Class::getObjectAttribute($object, $attributeName); $this->assertEquals('Test', $actual); }
/** * Test setThreshold method */ public function testSetThreshold() { $thresholdKey = \Magento\Framework\Profiler\Driver\Standard\Stat::TIME; $this->_output->setThreshold($thresholdKey, 100); $thresholds = class_exists('PHPUnit_Util_Class') ? \PHPUnit_Util_Class::getObjectAttribute($this->_output, '_thresholds') : \PHPUnit_Framework_Assert::readAttribute($this->_output, '_thresholds'); $this->assertArrayHasKey($thresholdKey, $thresholds); $this->assertEquals(100, $thresholds[$thresholdKey]); $this->_output->setThreshold($thresholdKey, null); $this->assertArrayNotHasKey($thresholdKey, $this->_output->getThresholds()); }
/** * Test setThreshold method */ public function testSetThreshold() { $thresholdKey = Magento_Profiler_Driver_Standard_Stat::TIME; $this->_output->setThreshold($thresholdKey, 100); $thresholds = PHPUnit_Util_Class::getObjectAttribute($this->_output, '_thresholds'); $this->assertArrayHasKey($thresholdKey, $thresholds); $this->assertEquals(100, $thresholds[$thresholdKey]); $this->_output->setThreshold($thresholdKey, null); $this->assertArrayNotHasKey($thresholdKey, $this->_output->getThresholds()); }
/** * @param string $suiteClassName * @param string $suiteClassFile * @return ReflectionClass * @throws RuntimeException */ public function load($suiteClassName, $suiteClassFile = '') { $suiteClassName = str_replace('.php', '', $suiteClassName); if (empty($suiteClassFile)) { $suiteClassFile = PHPUnit_Util_Filesystem::classNameToFilename($suiteClassName); } if (!class_exists($suiteClassName, FALSE)) { PHPUnit_Util_Class::collectStart(); $filename = PHPUnit_Util_Fileloader::checkAndLoad($suiteClassFile); $loadedClasses = PHPUnit_Util_Class::collectEnd(); } if (!class_exists($suiteClassName, FALSE) && !empty($loadedClasses)) { $offset = 0 - strlen($suiteClassName); foreach ($loadedClasses as $loadedClass) { $class = new ReflectionClass($loadedClass); if (substr($loadedClass, $offset) === $suiteClassName && $class->getFileName() == $filename) { $suiteClassName = $loadedClass; break; } } } if (!class_exists($suiteClassName, FALSE) && !empty($loadedClasses)) { $testCaseClass = 'PHPUnit_Framework_TestCase'; foreach ($loadedClasses as $loadedClass) { $class = new ReflectionClass($loadedClass); $classFile = $class->getFileName(); if ($class->isSubclassOf($testCaseClass) && !$class->isAbstract()) { $suiteClassName = $loadedClass; $testCaseClass = $loadedClass; if ($classFile == realpath($suiteClassFile)) { break; } } if ($class->hasMethod('suite')) { $method = $class->getMethod('suite'); if (!$method->isAbstract() && $method->isPublic() && $method->isStatic()) { $suiteClassName = $loadedClass; if ($classFile == realpath($suiteClassFile)) { break; } } } } } if (class_exists($suiteClassName, FALSE)) { $class = new ReflectionClass($suiteClassName); $filePath = $GLOBALS['base_dir'] . DIRECTORY_SEPARATOR . 'tests' . DIRECTORY_SEPARATOR . 'phpunit' . DIRECTORY_SEPARATOR . $suiteClassFile; if ($class->getFileName() == realpath($filePath)) { return $class; } } throw new PHPUnit_Framework_Exception(sprintf('Class %s could not be found in %s.', $suiteClassName, $suiteClassFile)); }
#!/usr/bin/env php <?php require dirname(__DIR__) . '/PHPUnit/Autoload.php'; $buffer = ''; $class = new ReflectionClass('PHPUnit_Framework_Assert'); $methods = array(); foreach ($class->getMethods() as $method) { $docblock = $method->getDocComment(); $name = $method->getName(); if (strpos($name, 'assert') === 0 || strpos($docblock, '@return PHPUnit_Framework_Constraint') !== FALSE) { $methods[$name] = array('class' => 'PHPUnit_Framework_Assert', 'docblock' => $docblock, 'sigDecl' => str_replace(array('= false', '= true'), array('= FALSE', '= TRUE'), PHPUnit_Util_Class::getMethodParameters($method)), 'sigCall' => PHPUnit_Util_Class::getMethodParameters($method, TRUE)); } } $class = new ReflectionClass('PHPUnit_Framework_TestCase'); foreach ($class->getMethods() as $method) { $docblock = $method->getDocComment(); $name = $method->getName(); if (strpos($docblock, '@return PHPUnit_Framework_MockObject_Matcher') !== FALSE || strpos($docblock, '@return PHPUnit_Framework_MockObject_Stub') !== FALSE) { $methods[$name] = array('class' => 'PHPUnit_Framework_TestCase', 'docblock' => $docblock, 'sigDecl' => str_replace(array('= false', '= true'), array('= FALSE', '= TRUE'), PHPUnit_Util_Class::getMethodParameters($method)), 'sigCall' => PHPUnit_Util_Class::getMethodParameters($method, TRUE)); } } ksort($methods); foreach ($methods as $name => $data) { $buffer .= sprintf("\n\n%s\nfunction %s(%s)\n{\n return call_user_func_array(\n '%s::%s',\n func_get_args()\n );\n}", str_replace(' ', '', $data['docblock']), $name, $data['sigDecl'], $data['class'], $name, $data['sigCall']); } $template = new Text_Template(dirname(__DIR__) . '/PHPUnit/Framework/Assert/Functions.php.in'); $template->setVar(array('functions' => $buffer)); $template->renderTo(dirname(__DIR__) . '/PHPUnit/Framework/Assert/Functions.php');
/** * Constructor. * * @param string $scope * @param ReflectionFunction|ReflectionMethod $function * @param array $codeCoverage */ protected function __construct($scope, $function, &$codeCoverage = array()) { $this->scope = $scope; $this->function = $function; $source = PHPUnit_Util_Class::getMethodSource($scope, $function->getName()); if ($source !== FALSE) { $this->tokens = token_get_all('<?php' . $source . '?>'); $this->parameters = $function->getNumberOfParameters(); $this->calculateCCN(); $this->calculateNPath(); $this->calculateDependencies(); } $this->setCoverage($codeCoverage); }
/** * Constructor. * * @param string $inClassName * @param string $inSourceFile * @param string $outClassName * @param string $outSourceFile * @since Method available since Release 3.4.0 */ public function __construct($inClassName, $inSourceFile = '', $outClassName = '', $outSourceFile = '') { $this->inClassName = PHPUnit_Util_Class::parseFullyQualifiedClassName($inClassName); $this->outClassName = PHPUnit_Util_Class::parseFullyQualifiedClassName($outClassName); $this->inSourceFile = str_replace($this->inClassName['fullyQualifiedClassName'], $this->inClassName['className'], $inSourceFile); $this->outSourceFile = str_replace($this->outClassName['fullyQualifiedClassName'], $this->outClassName['className'], $outSourceFile); }
/** * 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_Warning</code> will be created instead, * leaving the current test run untouched. * * @param string $filename * @param boolean $syntaxCheck * @param array $phptOptions Array with ini settings for the php instance * run, key being the name if the setting, * value the ini value. * @throws InvalidArgumentException * @access public * @since Method available since Release 2.3.0 * @author Stefano F. Rausch <*****@*****.**> */ public function addTestFile($filename, $syntaxCheck = TRUE, $phptOptions = array()) { if (!is_string($filename)) { throw new InvalidArgumentException(); } if (file_exists($filename) && substr($filename, -5) == '.phpt') { $this->addTest(new PHPUnit_Extensions_PhptTestCase($filename, $phptOptions)); return; } if (!file_exists($filename)) { $includePaths = explode(PATH_SEPARATOR, get_include_path()); foreach ($includePaths as $includePath) { $file = $includePath . DIRECTORY_SEPARATOR . $filename; if (file_exists($file)) { $filename = $file; break; } } } PHPUnit_Util_Class::collectStart(); PHPUnit_Util_Fileloader::checkAndLoad($filename, $syntaxCheck); $newClasses = PHPUnit_Util_Class::collectEnd(); $testsFound = FALSE; foreach ($newClasses as $className) { $class = new ReflectionClass($className); if (!$class->isAbstract()) { if ($class->hasMethod(PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME)) { $method = $class->getMethod(PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME); if ($method->isStatic()) { $this->addTest($method->invoke(NULL, $className)); $testsFound = TRUE; } } else { if ($class->implementsInterface('PHPUnit_Framework_Test')) { $this->addTestSuite($class); $testsFound = TRUE; } } } } if (!$testsFound) { $this->addTest(new PHPUnit_Framework_Warning('No tests found in file "' . $filename . '".')); } $this->numTests = -1; }
protected function processFunctions() { $functions = PHPUnit_Util_Class::getFunctionsInFile($this->getPath()); if (count($functions) > 0 && !isset($this->classes['*'])) { $this->classes['*'] = array('methods' => array(), 'startLine' => 0, 'executableLines' => 0, 'executedLines' => 0); } foreach ($functions as $function) { $functionName = $function->getName(); $functionStartLine = $function->getStartLine(); $functionEndLine = $function->getEndLine(); $this->classes['*']['methods'][$functionName] = array('startLine' => $functionStartLine, 'executableLines' => 0, 'executedLines' => 0); $this->startLines[$functionStartLine] =& $this->classes['*']['methods'][$functionName]; $this->endLines[$functionEndLine] =& $this->classes['*']['methods'][$functionName]; $this->numMethods++; } }
protected function generateConstructorCodeWithParentCall(ReflectionClass $class) { $constructor = $this->getConstructor($class); if ($constructor) { return sprintf(" public function __construct(%s) {\n" . " \$args = func_get_args();\n" . " \$this->invocationMocker = new PHPUnit_Framework_MockObject_InvocationMocker;\n" . " \$class = new ReflectionClass(\$this);\n" . " \$class->getParentClass()->getConstructor()->invokeArgs(\$this, \$args);\n" . " }\n\n", PHPUnit_Util_Class::getMethodParameters($constructor)); } else { return $this->generateConstructorCode($class); } }
/** * A testsuite started. * * @param PHPUnit_Framework_TestSuite $suite * @since Method available since Release 2.2.0 */ public function startTestSuite(PHPUnit_Framework_TestSuite $suite) { $testSuite = $this->document->createElement('testsuite'); $testSuite->setAttribute('name', $suite->getName()); if (class_exists($suite->getName(), FALSE)) { try { $class = new ReflectionClass($suite->getName()); $testSuite->setAttribute('file', $class->getFileName()); $packageInformation = PHPUnit_Util_Class::getPackageInformation($suite->getName(), $class->getDocComment()); if (!empty($packageInformation['namespace'])) { $testSuite->setAttribute('namespace', $packageInformation['namespace']); } if (!empty($packageInformation['fullPackage'])) { $testSuite->setAttribute('fullPackage', $packageInformation['fullPackage']); } if (!empty($packageInformation['category'])) { $testSuite->setAttribute('category', $packageInformation['category']); } if (!empty($packageInformation['package'])) { $testSuite->setAttribute('package', $packageInformation['package']); } if (!empty($packageInformation['subpackage'])) { $testSuite->setAttribute('subpackage', $packageInformation['subpackage']); } } catch (ReflectionException $e) { } } if ($this->testSuiteLevel > 0) { $this->testSuites[$this->testSuiteLevel]->appendChild($testSuite); } else { $this->root->appendChild($testSuite); } $this->testSuiteLevel++; $this->testSuites[$this->testSuiteLevel] = $testSuite; $this->testSuiteTests[$this->testSuiteLevel] = 0; $this->testSuiteAssertions[$this->testSuiteLevel] = 0; $this->testSuiteErrors[$this->testSuiteLevel] = 0; $this->testSuiteFailures[$this->testSuiteLevel] = 0; $this->testSuiteTimes[$this->testSuiteLevel] = 0; }
/** * Returns the value of an attribute of a class or an object. * This also works for attributes that are declared protected or private. * * @param mixed $classOrObject * @param string $attributeName * @return mixed * @throws PHPUnit_Framework_Exception */ public static function readAttribute($classOrObject, $attributeName) { if (!is_string($attributeName)) { throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string'); } if (is_string($classOrObject)) { if (!class_exists($classOrObject)) { throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'class name'); } return PHPUnit_Util_Class::getStaticAttribute($classOrObject, $attributeName); } else { if (is_object($classOrObject)) { return PHPUnit_Util_Class::getObjectAttribute($classOrObject, $attributeName); } else { throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'class name or object'); } } }
/** * Runs a TestCase. * * @param PHPUnit_Framework_Test $test */ public function run(PHPUnit_Framework_Test $test) { PHPUnit_Framework_Assert::resetCount(); $error = FALSE; $failure = FALSE; $incomplete = FALSE; $skipped = FALSE; $this->startTest($test); $errorHandlerSet = FALSE; if ($this->convertErrorsToExceptions) { $oldErrorHandler = set_error_handler(array('PHPUnit_Util_ErrorHandler', 'handleError'), E_ALL | E_STRICT); if ($oldErrorHandler === NULL) { $errorHandlerSet = TRUE; } else { restore_error_handler(); } } if (self::$xdebugLoaded === NULL) { self::$xdebugLoaded = extension_loaded('xdebug'); self::$useXdebug = self::$xdebugLoaded; } $useXdebug = self::$useXdebug && $this->codeCoverage !== NULL && !$test instanceof PHPUnit_Extensions_SeleniumTestCase && !$test instanceof PHPUnit_Framework_Warning; if ($useXdebug) { // We need to blacklist test source files when no whitelist is used. if (!$this->codeCoverage->filter()->hasWhitelist()) { $classes = PHPUnit_Util_Class::getHierarchy(get_class($test), TRUE); foreach ($classes as $class) { $this->codeCoverage->filter()->addFileToBlacklist($class->getFileName()); } } $this->codeCoverage->start($test); } PHP_Timer::start(); try { if (!$test instanceof PHPUnit_Framework_Warning && $this->strictMode && extension_loaded('pcntl') && class_exists('PHP_Invoker')) { switch ($test->getSize()) { case PHPUnit_Util_Test::SMALL: $_timeout = $this->timeoutForSmallTests; break; case PHPUnit_Util_Test::MEDIUM: $_timeout = $this->timeoutForMediumTests; break; case PHPUnit_Util_Test::LARGE: $_timeout = $this->timeoutForLargeTests; break; } $invoker = new PHP_Invoker(); $invoker->invoke(array($test, 'runBare'), array(), $_timeout); } else { $test->runBare(); } } catch (PHPUnit_Framework_AssertionFailedError $e) { $failure = TRUE; if ($e instanceof PHPUnit_Framework_IncompleteTestError) { $incomplete = TRUE; } else { if ($e instanceof PHPUnit_Framework_SkippedTestError) { $skipped = TRUE; } } } catch (Exception $e) { $error = TRUE; } $time = PHP_Timer::stop(); $test->addToAssertionCount(PHPUnit_Framework_Assert::getCount()); if ($this->strictMode && $test->getNumAssertions() == 0) { $incomplete = TRUE; } if ($useXdebug) { try { $this->codeCoverage->stop(!$incomplete && !$skipped); } catch (PHP_CodeCoverage_Exception $cce) { $error = TRUE; if (!isset($e)) { $e = $cce; } } } if ($errorHandlerSet === TRUE) { restore_error_handler(); } if ($error === TRUE) { $this->addError($test, $e, $time); } else { if ($failure === TRUE) { $this->addFailure($test, $e, $time); } else { if ($this->strictMode && $test->getNumAssertions() == 0) { $this->addFailure($test, new PHPUnit_Framework_IncompleteTestError('This test did not perform any assertions'), $time); } else { if ($this->strictMode && $test->hasOutput()) { $this->addFailure($test, new PHPUnit_Framework_OutputError(sprintf('This test printed output: %s', $test->getActualOutput())), $time); } } } } $this->endTest($test, $time); }
/** * Stores code coverage information. * * @param PHPUnit_Framework_TestResult $result * @param integer $revision * @access public */ public function storeCodeCoverage(PHPUnit_Framework_TestResult $result, $revision) { $codeCoverage = $result->getCodeCoverageInformation(FALSE, TRUE); $summary = PHPUnit_Util_CodeCoverage::getSummary($codeCoverage); $files = array_keys($summary); $commonPath = PHPUnit_Util_Filesystem::getCommonPath($files); $this->dbh->beginTransaction(); foreach ($files as $file) { $filename = str_replace($commonPath, '', $file); $fileId = FALSE; $lines = file($file); $numLines = count($lines); $stmt = $this->dbh->query(sprintf('SELECT code_file_id FROM code_file WHERE code_file_name = "%s" AND revision = %d;', $filename, $revision)); if ($stmt) { $fileId = (int) $stmt->fetchColumn(); } unset($stmt); if ($fileId == 0) { $this->dbh->exec(sprintf('INSERT INTO code_file (code_file_name, code_file_md5, revision) VALUES("%s", "%s", %d);', $filename, md5_file($file), $revision)); $fileId = $this->dbh->lastInsertId(); $classes = PHPUnit_Util_Class::getClassesInFile($file, $commonPath); foreach ($classes as $class) { $this->dbh->exec(sprintf('INSERT INTO code_class (code_file_id, code_class_name, code_class_start_line, code_class_end_line) VALUES(%d, "%s", %d, %d);', $fileId, $class->getName(), $class->getStartLine(), $class->getEndLine())); $classId = $this->dbh->lastInsertId(); foreach ($class->getMethods() as $method) { if ($class->getName() != $method->getDeclaringClass()->getName()) { continue; } $this->dbh->exec(sprintf('INSERT INTO code_method (code_class_id, code_method_name, code_method_start_line, code_method_end_line) VALUES(%d, "%s", %d, %d);', $classId, $method->getName(), $method->getStartLine(), $method->getEndLine())); } } $i = 1; foreach ($lines as $line) { $this->dbh->exec(sprintf('INSERT INTO code_line (code_file_id, code_line_number, code_line, code_line_covered) VALUES(%d, %d, "%s", %d);', $fileId, $i, trim($line), isset($summary[$file][$i]) ? $summary[$file][$i] : 0)); $i++; } } for ($lineNumber = 1; $lineNumber <= $numLines; $lineNumber++) { $coveringTests = PHPUnit_Util_CodeCoverage::getCoveringTests($codeCoverage, $file, $lineNumber); if (is_array($coveringTests)) { $stmt = $this->dbh->query(sprintf('SELECT code_line_id, code_line_covered FROM code_line WHERE code_file_id = %d AND code_line_number = %d;', $fileId, $lineNumber)); $codeLineId = (int) $stmt->fetchColumn(0); $oldCoverageFlag = (int) $stmt->fetchColumn(1); unset($stmt); $newCoverageFlag = $summary[$file][$lineNumber]; if ($oldCoverageFlag == 0 && $newCoverageFlag != 0 || $oldCoverageFlag < 0 && $newCoverageFlag > 0) { $this->dbh->exec(sprintf('UPDATE code_line SET code_line_covered = %d WHERE code_line_id = %d;', $newCoverageFlag, $codeLineId)); } foreach ($coveringTests as $test) { $this->dbh->exec(sprintf('INSERT INTO code_coverage (test_id, code_line_id) VALUES(%d, %d);', $test->__db_id, $codeLineId)); } } } } foreach ($result->topTestSuite() as $test) { if ($test instanceof PHPUnit_Framework_TestCase) { $stmt = $this->dbh->query(sprintf('SELECT code_method.code_method_id FROM code_class, code_method WHERE code_class.code_class_id = code_method.code_class_id AND code_class.code_class_name = "%s" AND code_method.code_method_name = "%s";', get_class($test), $test->getName())); $methodId = (int) $stmt->fetchColumn(); unset($stmt); $this->dbh->exec(sprintf('UPDATE test SET code_method_id = %d WHERE test_id = %d;', $methodId, $test->__db_id)); } } $this->dbh->commit(); }
/** * Constructor. * * @param string $filename * @param array $codeCoverage * @throws RuntimeException */ protected function __construct($filename, &$codeCoverage = array()) { if (!file_exists($filename)) { throw new RuntimeException(sprintf('File "%s" not found.', $filename)); } $this->filename = $filename; $this->lines = file($filename); $this->tokens = token_get_all(file_get_contents($filename)); $this->countLines(); $this->setCoverage($codeCoverage); foreach (PHPUnit_Util_Class::getClassesInFile($filename) as $class) { $this->classes[$class->getName()] = PHPUnit_Util_Metrics_Class::factory($class, $codeCoverage); } foreach (PHPUnit_Util_Class::getFunctionsInFile($filename) as $function) { $this->functions[$function->getName()] = PHPUnit_Util_Metrics_Function::factory($function, $codeCoverage); } }
/** * Returns the value of an object's attribute. * This also works for attributes that are declared protected or private. * * @param object $object * @param string $attributeName * @return mixed * @throws InvalidArgumentException * @since Method available since Release 3.1.0 */ public static function getObjectAttribute($object, $attributeName) { if (!is_object($object) || !is_string($attributeName)) { throw new InvalidArgumentException(); } self::assertObjectHasAttribute($attributeName, $object); try { $attribute = new ReflectionProperty($object, $attributeName); } catch (ReflectionException $e) { // Workaround for http://bugs.php.net/46064 if (version_compare(PHP_VERSION, '5.2.7', '<')) { $reflector = new ReflectionObject($object); $attributes = $reflector->getProperties(); foreach ($attributes as $_attribute) { if ($_attribute->getName() == $attributeName) { $attribute = $_attribute; break; } } } $reflector = new ReflectionObject($object); while ($reflector = $reflector->getParentClass()) { try { $attribute = $reflector->getProperty($attributeName); break; } catch (ReflectionException $e) { } } } if ($attribute->isPublic()) { return $object->{$attributeName}; } else { $array = (array) $object; $protectedName = "*" . $attributeName; if (array_key_exists($protectedName, $array)) { return $array[$protectedName]; } else { $classes = PHPUnit_Util_Class::getHierarchy(get_class($object)); foreach ($classes as $class) { $privateName = sprintf("%s%s", $class, $attributeName); if (array_key_exists($privateName, $array)) { return $array[$privateName]; } } } } throw new RuntimeException(sprintf('Attribute "%s" not found in object.', $attributeName)); }
/** * Tests access to data stored in {@link phpucAbstractAntTask::$properties} * * @covers phpucAbstractAntTask::__set * @covers phpucAbstractAntTask::__get * @covers phpucAbstractAntTask::__isset * * @return void */ public function testDefinedProperties() { $buildFile = $this->getMock('phpucBuildFile', array(), array(), '', false); $exec = phpucAbstractAntTask::create($buildFile, 'exec'); $php = 'php5'; $exec->executable = $php; $properties = PHPUnit_Util_Class::getObjectAttribute($exec, 'properties'); $this->assertEquals($php, $properties['executable']); $this->assertEquals($php, $exec->executable); $this->assertTrue(isset($exec->executable)); $this->assertFalse(isset($exec->foobar)); }
/** * @param PHPUnit_Framework_TestResult $result * @todo Count conditionals. */ public function process(PHPUnit_Framework_TestResult $result) { $time = time(); $document = new DOMDocument('1.0', 'UTF-8'); $document->formatOutput = TRUE; $coverage = $document->createElement('coverage'); $coverage->setAttribute('generated', $time); $coverage->setAttribute('phpunit', PHPUnit_Runner_Version::id()); $document->appendChild($coverage); $project = $document->createElement('project'); $project->setAttribute('name', $result->topTestSuite()->getName()); $project->setAttribute('timestamp', $time); $coverage->appendChild($project); $codeCoverageInformation = $result->getCodeCoverageInformation(); $files = PHPUnit_Util_CodeCoverage::getSummary($codeCoverageInformation); $packages = array(); $projectFiles = 0; $projectLoc = 0; $projectNcloc = 0; $projectClasses = 0; $projectMethods = 0; $projectCoveredMethods = 0; $projectConditionals = 0; $projectCoveredConditionals = 0; $projectStatements = 0; $projectCoveredStatements = 0; foreach ($files as $filename => $data) { $projectFiles++; $fileClasses = 0; $fileConditionals = 0; $fileCoveredConditionals = 0; $fileStatements = 0; $fileCoveredStatements = 0; $fileMethods = 0; $fileCoveredMethods = 0; $file = $document->createElement('file'); $file->setAttribute('name', $filename); $namespace = 'global'; $classes = PHPUnit_Util_Class::getClassesInFile($filename); $lines = array(); foreach ($classes as $class) { if ($class->isInterface()) { continue; } $className = $class->getName(); $methods = $class->getMethods(); $packageInformation = PHPUnit_Util_Class::getPackageInformation($className); $numMethods = 0; $fileClasses++; $projectClasses++; if (!empty($packageInformation['namespace'])) { $namespace = $packageInformation['namespace']; } $classConditionals = 0; $classCoveredConditionals = 0; $classStatements = 0; $classCoveredStatements = 0; $classCoveredMethods = 0; foreach ($methods as $method) { if ($method->getDeclaringClass()->getName() == $class->getName()) { $startLine = $method->getStartLine(); $endLine = $method->getEndLine(); $tests = array(); for ($i = $startLine; $i <= $endLine; $i++) { if (isset($files[$filename][$i])) { if (is_array($files[$filename][$i])) { foreach ($files[$filename][$i] as $_test) { $add = TRUE; foreach ($tests as $test) { if ($test === $_test) { $add = FALSE; break; } } if ($add) { $tests[] = $_test; } } $classCoveredStatements++; } $classStatements++; } } $count = count($tests); $lines[$startLine] = array('count' => $count, 'type' => 'method'); if ($count > 0) { $classCoveredMethods++; $fileCoveredMethods++; $projectCoveredMethods++; } $classStatements--; $numMethods++; $fileMethods++; $projectMethods++; } } $classXML = $document->createElement('class'); $classXML->setAttribute('name', $className); $classXML->setAttribute('namespace', $namespace); if (!empty($packageInformation['fullPackage'])) { $classXML->setAttribute('fullPackage', $packageInformation['fullPackage']); } if (!empty($packageInformation['category'])) { $classXML->setAttribute('category', $packageInformation['category']); } if (!empty($packageInformation['package'])) { $classXML->setAttribute('package', $packageInformation['package']); } if (!empty($packageInformation['subpackage'])) { $classXML->setAttribute('subpackage', $packageInformation['subpackage']); } $file->appendChild($classXML); $classMetricsXML = $document->createElement('metrics'); $classMetricsXML->setAttribute('methods', $numMethods); $classMetricsXML->setAttribute('coveredmethods', $classCoveredMethods); //$classMetricsXML->setAttribute('conditionals', $classConditionals); //$classMetricsXML->setAttribute('coveredconditionals', $classCoveredConditionals); $classMetricsXML->setAttribute('statements', $classStatements); $classMetricsXML->setAttribute('coveredstatements', $classCoveredStatements); $classMetricsXML->setAttribute('elements', $classConditionals + $classStatements + $numMethods); $classMetricsXML->setAttribute('coveredelements', $classCoveredConditionals + $classCoveredStatements + $classCoveredMethods); $classXML->appendChild($classMetricsXML); } foreach ($data as $_line => $_data) { if (is_array($_data)) { $count = count($_data); } else { if ($_data == -1) { $count = 0; } else { if ($_data == -2) { continue; } } } $lines[$_line] = array('count' => $count, 'type' => 'stmt'); } ksort($lines); foreach ($lines as $_line => $_data) { $line = $document->createElement('line'); $line->setAttribute('num', $_line); $line->setAttribute('type', $_data['type']); $line->setAttribute('count', $_data['count']); if ($_data['type'] == 'stmt') { if ($_data['count'] != 0) { $fileCoveredStatements++; } $fileStatements++; } $file->appendChild($line); } if (file_exists($filename)) { $fileMetrics = PHPUnit_Util_Metrics_File::factory($filename, $files); $fileLoc = $fileMetrics->getLoc(); $fileNcloc = $fileMetrics->getNcloc(); $fileMetricsXML = $document->createElement('metrics'); $fileMetricsXML->setAttribute('loc', $fileLoc); $fileMetricsXML->setAttribute('ncloc', $fileNcloc); $fileMetricsXML->setAttribute('classes', $fileClasses); $fileMetricsXML->setAttribute('methods', $fileMethods); $fileMetricsXML->setAttribute('coveredmethods', $fileCoveredMethods); //$fileMetricsXML->setAttribute('conditionals', $fileConditionals); //$fileMetricsXML->setAttribute('coveredconditionals', $fileCoveredConditionals); $fileMetricsXML->setAttribute('statements', $fileStatements); $fileMetricsXML->setAttribute('coveredstatements', $fileCoveredStatements); $fileMetricsXML->setAttribute('elements', $fileConditionals + $fileStatements + $fileMethods); $fileMetricsXML->setAttribute('coveredelements', $fileCoveredConditionals + $fileCoveredStatements + $fileCoveredMethods); $file->appendChild($fileMetricsXML); if ($namespace == 'global') { $project->appendChild($file); } else { if (!isset($packages[$namespace])) { $packages[$namespace] = $document->createElement('package'); $packages[$namespace]->setAttribute('name', $namespace); $project->appendChild($packages[$namespace]); } $packages[$namespace]->appendChild($file); } $projectLoc += $fileLoc; $projectNcloc += $fileNcloc; $projectStatements += $fileStatements; $projectCoveredStatements += $fileCoveredStatements; } } $projectMetricsXML = $document->createElement('metrics'); $projectMetricsXML->setAttribute('files', $projectFiles); $projectMetricsXML->setAttribute('loc', $projectLoc); $projectMetricsXML->setAttribute('ncloc', $projectNcloc); $projectMetricsXML->setAttribute('classes', $projectClasses); $projectMetricsXML->setAttribute('methods', $projectMethods); $projectMetricsXML->setAttribute('coveredmethods', $projectCoveredMethods); //$projectMetricsXML->setAttribute('conditionals', $projectConditionals); //$projectMetricsXML->setAttribute('coveredconditionals', $projectCoveredConditionals); $projectMetricsXML->setAttribute('statements', $projectStatements); $projectMetricsXML->setAttribute('coveredstatements', $projectCoveredStatements); $projectMetricsXML->setAttribute('elements', $projectConditionals + $projectStatements + $projectMethods); $projectMetricsXML->setAttribute('coveredelements', $projectCoveredConditionals + $projectCoveredStatements + $projectCoveredMethods); $project->appendChild($projectMetricsXML); $this->write($document->saveXML()); $this->flush(); }
/** * Calculates coverage statistics for the file. * * @access protected */ protected function calculateStatistics() { $classes = PHPUnit_Util_Class::getClassesInFile($this->getPath()); $startLines = array(); $endLines = array(); foreach ($classes as $class) { if (!$class->isInterface()) { $className = $class->getName(); $classStartLine = $class->getStartLine(); $classEndLine = $class->getEndLine(); $this->classes[$className] = array('methods' => array(), 'startLine' => $classStartLine, 'executableLines' => 0, 'executedLines' => 0); $startLines[$classStartLine] =& $this->classes[$className]; $endLines[$classEndLine] =& $this->classes[$className]; foreach ($class->getMethods() as $method) { if (!$method->isAbstract() && $method->getDeclaringClass()->getName() == $className) { $methodName = $method->getName(); $methodStartLine = $method->getStartLine(); $methodEndLine = $method->getEndLine(); $this->classes[$className]['methods'][$methodName] = array('startLine' => $methodStartLine, 'executableLines' => 0, 'executedLines' => 0); $startLines[$methodStartLine] =& $this->classes[$className]['methods'][$methodName]; $endLines[$methodEndLine] =& $this->classes[$className]['methods'][$methodName]; $this->numMethods++; } } $this->numClasses++; } } $ignoreStart = -1; $lineNumber = 1; foreach ($this->codeLines as $line) { if (isset($startLines[$lineNumber])) { // Start line of a class. if (isset($startLines[$lineNumber]['methods'])) { $currentClass =& $startLines[$lineNumber]; } else { $currentMethod =& $startLines[$lineNumber]; } } if (strpos($line, '@codeCoverageIgnore') !== FALSE) { if (strpos($line, '@codeCoverageIgnoreStart') !== FALSE) { $ignoreStart = $line; } else { if (strpos($line, '@codeCoverageIgnoreEnd') !== FALSE) { $ignoreStart = -1; } } } if (isset($this->executedLines[$lineNumber])) { // Array: Line is executable and was executed. if (is_array($this->executedLines[$lineNumber])) { if (isset($currentClass)) { $currentClass['executableLines']++; $currentClass['executedLines']++; } if (isset($currentMethod)) { $currentMethod['executableLines']++; $currentMethod['executedLines']++; } $this->numExecutableLines++; $this->numExecutedLines++; } else { if ($this->executedLines[$lineNumber] == -1) { if (isset($currentClass)) { $currentClass['executableLines']++; } if (isset($currentMethod)) { $currentMethod['executableLines']++; } $this->numExecutableLines++; if ($ignoreStart != -1 && $line > $ignoreStart) { if (isset($currentClass)) { $currentClass['executedLines']++; } if (isset($currentMethod)) { $currentMethod['executedLines']++; } $this->numExecutedLines++; } } } } if (isset($endLines[$lineNumber])) { // End line of a class. if (isset($endLines[$lineNumber]['methods'])) { unset($currentClass); } else { unset($currentMethod); } } $lineNumber++; } foreach ($this->classes as $class) { foreach ($class['methods'] as $method) { if ($method['executedLines'] > 0) { $this->numCalledMethods++; } } if ($class['executedLines'] > 0) { $this->numCalledClasses++; } } }
/** * Returns the names of the classes declared in a sourcefile. * * @param string $filename * @param string $commonPath * @param boolean $clearCache * @return array * @since Method available since Release 3.2.0 * @todo Find a better place for this method. */ public static function getFunctionsInFile($filename, $commonPath = '', $clearCache = FALSE) { if ($commonPath != '') { $filename = str_replace($commonPath, '', $filename); } if ($clearCache) { self::$fileFunctionMap = array(); } if (empty(self::$fileFunctionMap)) { $functions = get_defined_functions(); foreach ($functions['user'] as $functionName) { $function = new ReflectionFunction($functionName); $file = $function->getFileName(); if ($commonPath != '') { $file = str_replace($commonPath, '', $file); } if (!isset(self::$fileFunctionMap[$file])) { self::$fileFunctionMap[$file] = array($function); } else { self::$fileFunctionMap[$file][] = $function; } } } return isset(self::$fileFunctionMap[$filename]) ? self::$fileFunctionMap[$filename] : array(); }
/** * Returns the value of an object's attribute. * This also works for attributes that are declared protected or private. * * @param object $object * @param string $attributeName * @return mixed * @throws InvalidArgumentException * @access public * @static * @since Method available since Release 3.1.0 */ public static function getObjectAttribute($object, $attributeName) { if (!is_object($object) || !is_string($attributeName)) { throw new InvalidArgumentException(); } self::assertObjectHasAttribute($attributeName, $object); if (property_exists($object, $attributeName)) { return $object->{$attributeName}; } else { $array = (array) $object; $protectedName = "*" . $attributeName; if (array_key_exists($protectedName, $array)) { return $array[$protectedName]; } else { $classes = PHPUnit_Util_Class::getHierarchy(get_class($object)); foreach ($classes as $class) { $privateName = sprintf("%s%s", $class, $attributeName); if (array_key_exists($privateName, $array)) { return $array[$privateName]; } } } } throw new RuntimeException(sprintf('Attribute "%s" not found in object.', $attributeName)); }
/** * 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_Warning</code> will be created instead, * leaving the current test run untouched. * * @param string $filename * @param array $phptOptions Array with ini settings for the php instance * run, key being the name if the setting, * value the ini value. * @throws InvalidArgumentException * @since Method available since Release 2.3.0 * @author Stefano F. Rausch <*****@*****.**> */ public function addTestFile($filename, $phptOptions = array()) { if (!is_string($filename)) { throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string'); } if (file_exists($filename) && substr($filename, -5) == '.phpt') { require_once 'PHPUnit/Extensions/PhptTestCase.php'; $this->addTest(new PHPUnit_Extensions_PhptTestCase($filename, $phptOptions)); return; } if (!file_exists($filename)) { $includePaths = explode(PATH_SEPARATOR, get_include_path()); foreach ($includePaths as $includePath) { $file = $includePath . DIRECTORY_SEPARATOR . $filename; if (file_exists($file)) { $filename = $file; break; } } } PHPUnit_Util_Class::collectStart(); PHPUnit_Util_Fileloader::load($filename); $newClasses = PHPUnit_Util_Class::collectEnd(); $baseName = str_replace('.php', '', basename($filename)); foreach ($newClasses as $className) { if (substr($className, 0 - strlen($baseName)) == $baseName) { $newClasses = array($className); break; } } $testsFound = FALSE; foreach ($newClasses as $className) { $class = new ReflectionClass($className); if (!$class->isAbstract()) { if ($class->hasMethod(PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME)) { $method = $class->getMethod(PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME); if ($method->isStatic()) { $this->addTest($method->invoke(NULL, $className)); $testsFound = TRUE; } } else { if ($class->implementsInterface('PHPUnit_Framework_Test')) { $this->addTestSuite($class); $testsFound = TRUE; } } } } $this->numTests = -1; }
/** * Generates the definition of a method to be proxied. * * @param string $templateDir Location of the templates to be used to create the proxy. * @param \ReflectionMethod $method Name of the method to be reflected. * @return array Information about the method to be proxied. */ protected static function generateProxiedMethodDefinition($templateDir, \ReflectionMethod $method) { if ($method->returnsReference()) { $reference = '&'; } else { $reference = ''; } $template = self::createTemplateObject($templateDir . 'proxied_method.tpl'); $template->setVar(array('arguments_declaration' => \PHPUnit_Util_Class::getMethodParameters($method), 'arguments' => self::getMethodCallParameters($method), 'method_name' => $method->getName(), 'reference' => $reference)); return $template->render(); }
/** * Constructor. * * @param ReflectionClass $class * @param array $codeCoverage */ protected function __construct(ReflectionClass $class, &$codeCoverage = array()) { $this->class = $class; $className = $class->getName(); $packageInformation = PHPUnit_Util_Class::getPackageInformation($className); if (!empty($packageInformation['fullPackage'])) { $this->package = $packageInformation['fullPackage']; } $this->setCoverage($codeCoverage); $this->dit = count(PHPUnit_Util_Class::getHierarchy($class->getName())) - 1; $this->impl = count($class->getInterfaces()); foreach ($this->class->getMethods() as $method) { if ($method->getDeclaringClass()->getName() == $className) { $this->methods[$method->getName()] = PHPUnit_Util_Metrics_Function::factory($method, $codeCoverage); } else { $this->inheritedMethods[$method->getName()] = PHPUnit_Util_Metrics_Function::factory($method, $codeCoverage); } } $this->calculateAttributeMetrics(); $this->calculateMethodMetrics(); $this->calculateNumberOfChildren(); $this->calculatePolymorphismFactor(); $this->calculateDependencies(); }
/** * @param string $suiteClassName * @param string $suiteClassFile * @param boolean $syntaxCheck * @return ReflectionClass * @throws RuntimeException */ public function load($suiteClassName, $suiteClassFile = '', $syntaxCheck = TRUE) { $suiteClassName = str_replace('.php', '', $suiteClassName); if (empty($suiteClassFile)) { $suiteClassFile = str_replace(array('_', '\\'), DIRECTORY_SEPARATOR, $suiteClassName) . '.php'; } if (!class_exists($suiteClassName, FALSE)) { if (!file_exists($suiteClassFile)) { $includePaths = explode(PATH_SEPARATOR, get_include_path()); foreach ($includePaths as $includePath) { $file = $includePath . DIRECTORY_SEPARATOR . $suiteClassFile; if (file_exists($file)) { $suiteClassFile = $file; break; } } } PHPUnit_Util_Class::collectStart(); PHPUnit_Util_Fileloader::checkAndLoad($suiteClassFile, $syntaxCheck); $loadedClasses = PHPUnit_Util_Class::collectEnd(); } if (!class_exists($suiteClassName, FALSE) && !empty($loadedClasses)) { $offset = 0 - strlen($suiteClassName); foreach ($loadedClasses as $loadedClass) { if (substr($loadedClass, $offset) === $suiteClassName) { $suiteClassName = $loadedClass; break; } } } if (!class_exists($suiteClassName, FALSE) && !empty($loadedClasses)) { $testCaseClass = 'PHPUnit_Framework_TestCase'; foreach ($loadedClasses as $loadedClass) { $class = new ReflectionClass($loadedClass); if ($class->isSubclassOf($testCaseClass)) { $suiteClassName = $loadedClass; $testCaseClass = $loadedClass; if ($class->getFileName() == realpath($suiteClassFile)) { break; } } if ($class->hasMethod('suite')) { $method = $class->getMethod('suite'); if (!$method->isAbstract() && $method->isPublic() && $method->isStatic()) { $suiteClassName = $loadedClass; break; } } } } if (class_exists($suiteClassName, FALSE)) { $class = new ReflectionClass($suiteClassName); if ($class->getFileName() == realpath($suiteClassFile)) { return $class; } } throw new RuntimeException(sprintf('Class %s could not be found in %s.', $suiteClassName, $suiteClassFile)); }
/** * 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_Warning</code> will be created instead, * leaving the current test run untouched. * * @param string $filename * @param boolean $syntaxCheck * @param array $phptOptions Array with ini settings for the php instance * run, key being the name if the setting, * value the ini value. * @throws InvalidArgumentException * @since Method available since Release 2.3.0 * @author Stefano F. Rausch <*****@*****.**> */ public function addTestFile($filename, $syntaxCheck = FALSE, $phptOptions = array()) { if (!is_string($filename)) { throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string'); } if (file_exists($filename) && substr($filename, -5) == '.phpt') { $this->addTest(new PHPUnit_Extensions_PhptTestCase($filename, $phptOptions)); return; } PHPUnit_Util_Class::collectStart(); $filename = PHPUnit_Util_Fileloader::checkAndLoad($filename, $syntaxCheck); $newClasses = PHPUnit_Util_Class::collectEnd(); $baseName = str_replace('.php', '', basename($filename)); foreach ($newClasses as $className) { if (substr($className, 0 - strlen($baseName)) == $baseName) { $class = new ReflectionClass($className); if ($class->getFileName() == $filename) { $newClasses = array($className); break; } } } $testsFound = FALSE; foreach ($newClasses as $className) { $class = new ReflectionClass($className); if (!$class->isAbstract()) { if ($class->hasMethod(PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME)) { $method = $class->getMethod(PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME); if ($method->isStatic()) { $this->addTest($method->invoke(NULL, $className)); $testsFound = TRUE; } } else { if ($class->implementsInterface('PHPUnit_Framework_Test')) { $this->addTestSuite($class); $testsFound = TRUE; } } } } $this->numTests = -1; }
protected function handleCustomTestSuite() { $directory = getcwd(); $packages = $this->options[1]; if (isset($this->arguments['coverageClover']) || isset($this->arguments['reportDirectory'])) { $fillWhitelist = true; } else { $fillWhitelist = false; } $this->arguments['test'] = new PHPUnit_Framework_TestSuite(); $this->arguments['test']->setName('eZ Components'); if (empty($packages)) { $packages = $this->getPackages($directory); } foreach ($packages as $package) { $added = false; $slashCount = substr_count($package, DIRECTORY_SEPARATOR); if ($this->release == 'trunk' && $slashCount !== 0 || $this->release == 'stable' && $slashCount > 1) { if (file_exists($package)) { PHPUnit_Util_Class::collectStart(); require_once $package; $class = PHPUnit_Util_Class::collectEnd(); if (!empty($class)) { $this->arguments['test']->addTest(call_user_func(array(array_pop($class), 'suite'))); $added = true; $package = substr($package, 0, strpos($package, DIRECTORY_SEPARATOR)); } else { die("\n Cannot load: {$package}. \n"); } } } else { $suite = $this->getTestSuite($directory, $package); if (!is_null($suite)) { $this->arguments['test']->addTest($suite); $added = true; } } if ($fillWhitelist && $added) { foreach (glob($directory . '/' . $package . '/src/*_autoload.php') as $autoloadFile) { foreach (include $autoloadFile as $className => $fileName) { if (strpos($fileName, 'xmlwritersubstitute.php') === false) { PHPUnit_Util_Filter::addFileToWhitelist($directory . '/' . str_replace($package, $package . '/src', $fileName)); } } } } } if (isset($this->arguments['colors']) && $this->arguments['colors'] === true) { $colors = true; } else { $colors = false; } if (isset($this->arguments['debug']) && $this->arguments['debug'] === true) { $debug = true; } else { $debug = false; } if (isset($this->arguments['verbose']) && $this->arguments['verbose'] === true) { $verbose = true; } else { $verbose = false; } $this->arguments['printer'] = new ezcTestPrinter(NULL, $verbose, $colors, $debug); }
/** * Starts the collection of loaded classes. * */ public static function collectStart() { self::$buffer = get_declared_classes(); }
/** * @param string $templateDir * @param ReflectionMethod $method * @return string */ protected static function generateMockedMethodDefinitionFromExisting($templateDir, ReflectionMethod $method) { if ($method->isPrivate()) { $modifier = 'private'; } else { if ($method->isProtected()) { $modifier = 'protected'; } else { $modifier = 'public'; } } if ($method->isStatic()) { $static = TRUE; } else { $static = FALSE; } if ($method->returnsReference()) { $reference = '&'; } else { $reference = ''; } return self::generateMockedMethodDefinition($templateDir, $method->getDeclaringClass()->getName(), $method->getName(), $modifier, PHPUnit_Util_Class::getMethodParameters($method), PHPUnit_Util_Class::getMethodParameters($method, TRUE), $reference, $static); }