| <?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() {} |
| } |
| |
| } |
| ?> |
