Viewing file:  TestSuite.php (22.61 KB) -rwxrwxr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?php
/**
* PHPUnit
*
* Copyright (c) 2002-2008, Sebastian Bergmann <sb@sebastian-bergmann.de>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* * Neither the name of Sebastian Bergmann nor the names of his
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* @category Testing
* @package PHPUnit
* @author Sebastian Bergmann <sb@sebastian-bergmann.de>
* @copyright 2002-2008 Sebastian Bergmann <sb@sebastian-bergmann.de>
* @license http://www.opensource.org/licenses/bsd-license.php BSD License
* @version SVN: $Id: TestSuite.php 2157 2008-01-17 13:06:52Z sb $
* @link http://www.phpunit.de/
* @since File available since Release 2.0.0
*/
require_once 'PHPUnit/Framework.php';
require_once 'PHPUnit/Extensions/PhptTestCase.php';
require_once 'PHPUnit/Runner/BaseTestRunner.php';
require_once 'PHPUnit/Util/Class.php';
require_once 'PHPUnit/Util/Fileloader.php';
require_once 'PHPUnit/Util/Filter.php';
require_once 'PHPUnit/Util/Test.php';
require_once 'PHPUnit/Util/TestSuiteIterator.php';
PHPUnit_Util_Filter::addFileToFilter(__FILE__, 'PHPUNIT');
if (! class_exists('PHPUnit_Framework_TestSuite', FALSE)) {
/**
* A TestSuite is a composite of Tests. It runs a collection of test cases.
*
* Here is an example using the dynamic test definition.
*
* <code>
* <?php
* $suite = new PHPUnit_Framework_TestSuite;
* $suite->addTest(new MathTest('testPass'));
* ?>
* </code>
*
* Alternatively, a TestSuite can extract the tests to be run automatically.
* To do so you pass a ReflectionClass instance for your
* PHPUnit_Framework_TestCase class to the PHPUnit_Framework_TestSuite
* constructor.
*
* <code>
* <?php
* $suite = new PHPUnit_Framework_TestSuite(
* new ReflectionClass('MathTest')
* );
* ?>
* </code>
*
* This constructor creates a suite with all the methods starting with
* "test" that take no arguments.
*
* @category Testing
* @package PHPUnit
* @author Sebastian Bergmann <sb@sebastian-bergmann.de>
* @copyright 2002-2008 Sebastian Bergmann <sb@sebastian-bergmann.de>
* @license http://www.opensource.org/licenses/bsd-license.php BSD License
* @version Release: 3.2.9
* @link http://www.phpunit.de/
* @since Class available since Release 2.0.0
*/
class PHPUnit_Framework_TestSuite implements PHPUnit_Framework_Test, PHPUnit_Framework_SelfDescribing, IteratorAggregate {
/**
* Fixture that is shared between the tests of this test suite.
*
* @var mixed
* @access protected
*/
protected $sharedFixture;
/**
* The name of the test suite.
*
* @var string
* @access protected
*/
protected $name = '';
/**
* The test groups of the test suite.
*
* @var array
* @access protected
*/
protected $groups = array();
/**
* The tests in the test suite.
*
* @var array
* @access protected
*/
protected $tests = array();
/**
* The number of tests in the test suite.
*
* @var integer
* @access protected
*/
protected $numTests = - 1;
/**
* Constructs a new TestSuite:
*
* - PHPUnit_Framework_TestSuite() constructs an empty TestSuite.
*
* - PHPUnit_Framework_TestSuite(ReflectionClass) constructs a
* TestSuite from the given class.
*
* - PHPUnit_Framework_TestSuite(ReflectionClass, String)
* constructs a TestSuite from the given class with the given
* name.
*
* - PHPUnit_Framework_TestSuite(String) either constructs a
* TestSuite from the given class (if the passed string is the
* name of an existing class) or constructs an empty TestSuite
* with the given name.
*
* @param mixed $theClass
* @param string $name
* @throws InvalidArgumentException
* @access public
*/
public function __construct($theClass = '', $name = '') {
$argumentsValid = FALSE;
if (is_object($theClass) && $theClass instanceof ReflectionClass) {
$argumentsValid = TRUE;
}
else if (is_string($theClass) && $theClass !== '' && class_exists($theClass, FALSE)) {
$argumentsValid = TRUE;
if ($name == '') {
$name = $theClass;
}
$theClass = new ReflectionClass($theClass);
}
else if (is_string($theClass)) {
$this->setName($theClass);
return;
}
if (! $argumentsValid) {
throw new InvalidArgumentException();
}
PHPUnit_Util_Filter::addFileToFilter(realpath($theClass->getFilename()), 'TESTS');
if ($name != '') {
$this->setName($name);
} else {
$this->setName($theClass->getName());
}
$constructor = $theClass->getConstructor();
if ($constructor !== NULL && ! $constructor->isPublic()) {
$this->addTest(self::warning(sprintf('Class "%s" has no public constructor.',
$theClass->getName())));
return;
}
$className = $theClass->getName();
$names = array();
$classGroups = PHPUnit_Util_Test::getGroups($theClass);
foreach ($theClass->getMethods() as $method) {
if (strpos($method->getDeclaringClass()->getName(), 'PHPUnit_') !== 0) {
$this->addTestMethod($method, PHPUnit_Util_Test::getGroups($method, $classGroups), $names, $theClass);
}
}
if (empty($this->tests)) {
$this->addTest(self::warning(sprintf('No tests found in class "%s".',
$theClass->getName())));
}
}
/**
* Returns a string representation of the test suite.
*
* @return string
* @access public
*/
public function toString() {
return $this->getName();
}
/**
* Adds a test to the suite.
*
* @param PHPUnit_Framework_Test $test
* @param array $groups
* @access public
*/
public function addTest(PHPUnit_Framework_Test $test, $groups = array()) {
$this->tests[] = $test;
$this->numTests = - 1;
if ($test instanceof PHPUnit_Framework_TestSuite && empty($groups)) {
$groups = $test->getGroups();
}
if (empty($groups)) {
$groups = array('__nogroup__');
}
foreach ($groups as $group) {
if (! isset($this->groups[$group])) {
$this->groups[$group] = array($test);
} else {
$this->groups[$group][] = $test;
}
}
}
/**
* Adds the tests from the given class to the suite.
*
* @param mixed $testClass
* @throws InvalidArgumentException
* @access public
*/
public function addTestSuite($testClass) {
if (is_string($testClass) && class_exists($testClass)) {
$testClass = new ReflectionClass($testClass);
}
if (! is_object($testClass)) {
throw new InvalidArgumentException();
}
if ($testClass instanceof PHPUnit_Framework_TestSuite) {
$this->addTest($testClass);
}
else if ($testClass instanceof ReflectionClass) {
$suiteMethod = FALSE;
if (! $testClass->isAbstract()) {
if ($testClass->hasMethod(PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME)) {
$method = $testClass->getMethod(PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME);
if ($method->isStatic()) {
$this->addTest($method->invoke(NULL, $testClass->getName()));
$suiteMethod = TRUE;
}
}
}
if (! $suiteMethod) {
$this->addTest(new PHPUnit_Framework_TestSuite($testClass));
}
}
else {
throw new InvalidArgumentException();
}
}
/**
* 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 <stefano@rausch-e.net>
*/
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;
}
/**
* Wrapper for addTestFile() that adds multiple test files.
*
* @param array|Iterator $filenames
* @throws InvalidArgumentException
* @access public
* @since Method available since Release 2.3.0
*/
public function addTestFiles($filenames) {
if (! (is_array($filenames) || (is_object($filenames) && $filenames instanceof Iterator))) {
throw new InvalidArgumentException();
}
foreach ($filenames as $filename) {
$this->addTestFile((string)$filename);
}
}
/**
* Counts the number of test cases that will be run by this test.
*
* @return integer
* @access public
*/
public function count() {
if ($this->numTests > - 1) {
return $this->numTests;
}
$this->numTests = 0;
foreach ($this->tests as $test) {
$this->numTests += count($test);
}
return $this->numTests;
}
/**
* @param ReflectionClass $theClass
* @param string $name
* @return PHPUnit_Framework_Test
* @access public
* @static
*/
public static function createTest(ReflectionClass $theClass, $name) {
$className = $theClass->getName();
$method = new ReflectionMethod($className, $name);
$docComment = $method->getDocComment();
if (! $theClass->isInstantiable()) {
return self::warning(sprintf('Cannot instantiate class "%s".', $className));
}
// @expectedException ExceptionClass on TestCase::testMethod()
// @expectedException ExceptionClass message on TestCase::testMethod()
// @expectedException ExceptionClass message code on TestCase::testMethod()
if (preg_match('(@expectedException\s+([:.\w]+)(?:[\t ]+(\S*))?(?:[\t ]+(\S*))?[\t ]*$)m', $docComment, $matches)) {
$expectedException = $matches[1];
if (isset($matches[2])) {
$expectedExceptionMessage = trim($matches[2]);
} else {
$expectedExceptionMessage = '';
}
if (isset($matches[3])) {
$expectedExceptionCode = (int)$matches[3];
} else {
$expectedExceptionCode = 0;
}
}
$constructor = $theClass->getConstructor();
if ($constructor !== NULL) {
$parameters = $constructor->getParameters();
// TestCase() or TestCase($name)
if (count($parameters) < 2) {
$test = new $className();
}
// TestCase($name, $data)
else {
$data = PHPUnit_Util_Test::getProvidedData($className, $name);
if (is_array($data) || $data instanceof Iterator) {
$test = new PHPUnit_Framework_TestSuite($className . '::' . $name);
foreach ($data as $_dataName => $_data) {
$_test = new $className($name, $_data, $_dataName);
if ($_test instanceof PHPUnit_Framework_TestCase && isset($expectedException)) {
$_test->setExpectedException($expectedException, $expectedExceptionMessage, $expectedExceptionCode);
}
$test->addTest($_test);
}
} else {
$test = new $className();
}
}
}
if ($test instanceof PHPUnit_Framework_TestCase) {
$test->setName($name);
if (isset($expectedException)) {
$test->setExpectedException($expectedException, $expectedExceptionMessage, $expectedExceptionCode);
}
}
return $test;
}
/**
* Creates a default TestResult object.
*
* @return PHPUnit_Framework_TestResult
* @access protected
*/
protected function createResult() {
return new PHPUnit_Framework_TestResult();
}
/**
* Returns the name of the suite.
*
* @return string
* @access public
*/
public function getName() {
return $this->name;
}
/**
* Returns the test groups of the suite.
*
* @return array
* @access public
* @since Method available since Release 3.2.0
*/
public function getGroups() {
return array_keys($this->groups);
}
/**
* Runs the tests and collects their result in a TestResult.
*
* @param PHPUnit_Framework_TestResult $result
* @param mixed $filter
* @param array $groups
* @param array $excludeGroups
* @return PHPUnit_Framework_TestResult
* @throws InvalidArgumentException
* @access public
*/
public function run(PHPUnit_Framework_TestResult $result = NULL, $filter = FALSE, array $groups = array(), array $excludeGroups = array()) {
if ($result === NULL) {
$result = $this->createResult();
}
try {
$this->setUp();
}
catch (PHPUnit_Framework_SkippedTestSuiteError $e) {
$numTests = count($this);
for ($i = 0; $i < $numTests; $i ++) {
$result->addFailure($this, $e, 0);
}
return $result;
}
$result->startTestSuite($this);
$tests = array();
if (empty($excludeGroups)) {
if (empty($groups)) {
$tests = $this->tests;
} else {
foreach ($groups as $group) {
if (isset($this->groups[$group])) {
$tests = array_merge($tests, $this->groups[$group]);
}
}
}
} else {
foreach ($this->groups as $_group => $_tests) {
if (! in_array($_group, $excludeGroups)) {
$tests = array_merge($tests, $_tests);
}
}
}
foreach ($tests as $test) {
if ($result->shouldStop()) {
break;
}
if ($test instanceof PHPUnit_Framework_TestSuite) {
$test->setSharedFixture($this->sharedFixture);
$test->run($result, $filter, $groups, $excludeGroups);
} else {
$runTest = TRUE;
if ($filter !== FALSE) {
$name = $test->getName();
if ($name !== NULL && preg_match($filter, $name) == 0) {
$runTest = FALSE;
}
}
if ($runTest) {
if ($test instanceof PHPUnit_Framework_TestCase) {
$test->setSharedFixture($this->sharedFixture);
}
$this->runTest($test, $result);
}
}
}
$result->endTestSuite($this);
$this->tearDown();
return $result;
}
/**
* Runs a test.
*
* @param PHPUnit_Framework_Test $test
* @param PHPUnit_Framework_TestResult $testResult
* @access public
*/
public function runTest(PHPUnit_Framework_Test $test, PHPUnit_Framework_TestResult $result) {
$test->run($result);
}
/**
* Sets the name of the suite.
*
* @param string
* @access public
*/
public function setName($name) {
$this->name = $name;
}
/**
* Returns the test at the given index.
*
* @param integer
* @return PHPUnit_Framework_Test
* @access public
*/
public function testAt($index) {
if (isset($this->tests[$index])) {
return $this->tests[$index];
} else {
return FALSE;
}
}
/**
* Returns the number of tests in this suite.
*
* @return integer
* @access public
*/
public function testCount() {
return count($this->tests);
}
/**
* Returns the tests as an enumeration.
*
* @return array
* @access public
*/
public function tests() {
return $this->tests;
}
/**
* Mark the test suite as skipped.
*
* @param string $message
* @throws PHPUnit_Framework_SkippedTestSuiteError
* @access public
* @since Method available since Release 3.0.0
*/
public function markTestSuiteSkipped($message = '') {
throw new PHPUnit_Framework_SkippedTestSuiteError($message);
}
/**
* @param ReflectionMethod $method
* @param string $groups
* @param array $names
* @param ReflectionClass $theClass
* @access protected
*/
protected function addTestMethod(ReflectionMethod $method, $groups, Array &$names, ReflectionClass $theClass) {
$name = $method->getName();
if (in_array($name, $names)) {
return;
}
if ($this->isPublicTestMethod($method)) {
$names[] = $name;
$this->addTest(self::createTest($theClass, $name), $groups);
}
else if ($this->isTestMethod($method)) {
$this->addTest(self::warning(sprintf('Test method "%s" is not public.',
$name)));
}
}
/**
* @param ReflectionMethod $method
* @return boolean
* @access public
* @static
*/
public static function isPublicTestMethod(ReflectionMethod $method) {
return (self::isTestMethod($method) && $method->isPublic());
}
/**
* @param ReflectionMethod $method
* @return boolean
* @access public
* @static
*/
public static function isTestMethod(ReflectionMethod $method) {
if (strpos($method->name, 'test') === 0) {
return TRUE;
}
// @story on TestCase::testMethod()
// @test on TestCase::testMethod()
return strpos($method->getDocComment(), '@test') !== FALSE || strpos($method->getDocComment(), '@story') !== FALSE;
}
/**
* @param string $message
* @return PHPUnit_Framework_Warning
* @access protected
*/
protected static function warning($message) {
return new PHPUnit_Framework_Warning($message);
}
/**
* Sets the shared fixture for the tests of this test suite.
*
* @param mixed $sharedFixture
* @access public
* @since Method available since Release 3.1.0
*/
public function setSharedFixture($sharedFixture) {
$this->sharedFixture = $sharedFixture;
}
/**
* Returns an iterator for this test suite.
*
* @return RecursiveIteratorIterator
* @access public
* @since Method available since Release 3.1.0
*/
public function getIterator() {
return new RecursiveIteratorIterator(new PHPUnit_Util_TestSuiteIterator($this));
}
/**
* Template Method that is called before the tests
* of this test suite are run.
*
* @access protected
* @since Method available since Release 3.1.0
*/
protected function setUp() {}
/**
* Template Method that is called after the tests
* of this test suite have finished running.
*
* @access protected
* @since Method available since Release 3.1.0
*/
protected function tearDown() {}
}
}
?>
|