/**
* @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);
}
