Page Menu
Home
WickedGov Phorge
Search
Configure Global Search
Log In
Files
F7415507
TestSuite.php
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Flag For Later
Award Token
Size
26 KB
Referenced Files
None
Subscribers
None
TestSuite.php
View Options
<?php
declare
(
strict_types
=
1
);
/*
* This file is part of PHPUnit.
*
* (c) Sebastian Bergmann <sebastian@phpunit.de>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace
PHPUnit\Framework
;
use
const
PHP_EOL
;
use
function
array_keys
;
use
function
array_map
;
use
function
array_merge
;
use
function
array_slice
;
use
function
array_unique
;
use
function
basename
;
use
function
call_user_func
;
use
function
class_exists
;
use
function
count
;
use
function
dirname
;
use
function
get_declared_classes
;
use
function
implode
;
use
function
is_bool
;
use
function
is_callable
;
use
function
is_file
;
use
function
is_object
;
use
function
is_string
;
use
function
method_exists
;
use
function
preg_match
;
use
function
preg_quote
;
use
function
sprintf
;
use
function
strpos
;
use
function
substr
;
use
Iterator
;
use
IteratorAggregate
;
use
PHPUnit\Runner\BaseTestRunner
;
use
PHPUnit\Runner\Filter\Factory
;
use
PHPUnit\Runner\PhptTestCase
;
use
PHPUnit\Util\FileLoader
;
use
PHPUnit\Util\Reflection
;
use
PHPUnit\Util\Test
as
TestUtil
;
use
ReflectionClass
;
use
ReflectionException
;
use
ReflectionMethod
;
use
SebastianBergmann\CodeCoverage\UnintentionallyCoveredCodeException
;
use
Throwable
;
/**
* @template-implements IteratorAggregate<int, Test>
*
* @internal This class is not covered by the backward compatibility promise for PHPUnit
*/
class
TestSuite
implements
IteratorAggregate
,
Reorderable
,
SelfDescribing
,
Test
{
/**
* Enable or disable the backup and restoration of the $GLOBALS array.
*
* @var bool
*/
protected
$backupGlobals
;
/**
* Enable or disable the backup and restoration of static attributes.
*
* @var bool
*/
protected
$backupStaticAttributes
;
/**
* @var bool
*/
protected
$runTestInSeparateProcess
=
false
;
/**
* The name of the test suite.
*
* @var string
*/
protected
$name
=
''
;
/**
* The test groups of the test suite.
*
* @psalm-var array<string,list<Test>>
*/
protected
$groups
=
[];
/**
* The tests in the test suite.
*
* @var Test[]
*/
protected
$tests
=
[];
/**
* The number of tests in the test suite.
*
* @var int
*/
protected
$numTests
=
-
1
;
/**
* @var bool
*/
protected
$testCase
=
false
;
/**
* @var string[]
*/
protected
$foundClasses
=
[];
/**
* @var null|list<ExecutionOrderDependency>
*/
protected
$providedTests
;
/**
* @var null|list<ExecutionOrderDependency>
*/
protected
$requiredTests
;
/**
* @var bool
*/
private
$beStrictAboutChangesToGlobalState
;
/**
* @var Factory
*/
private
$iteratorFilter
;
/**
* @var int
*/
private
$declaredClassesPointer
;
/**
* @psalm-var array<int,string>
*/
private
$warnings
=
[];
/**
* 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 ReflectionClass|string $theClass
*
* @throws Exception
*/
public
function
__construct
(
$theClass
=
''
,
string
$name
=
''
)
{
if
(!
is_string
(
$theClass
)
&&
!
$theClass
instanceof
ReflectionClass
)
{
throw
InvalidArgumentException
::
create
(
1
,
'ReflectionClass object or string'
,
);
}
$this
->
declaredClassesPointer
=
count
(
get_declared_classes
());
if
(!
$theClass
instanceof
ReflectionClass
)
{
if
(
class_exists
(
$theClass
,
true
))
{
if
(
$name
===
''
)
{
$name
=
$theClass
;
}
try
{
$theClass
=
new
ReflectionClass
(
$theClass
);
}
catch
(
ReflectionException
$e
)
{
throw
new
Exception
(
$e
->
getMessage
(),
$e
->
getCode
(),
$e
,
);
}
// @codeCoverageIgnoreEnd
}
else
{
$this
->
setName
(
$theClass
);
return
;
}
}
if
(!
$theClass
->
isSubclassOf
(
TestCase
::
class
))
{
$this
->
setName
((
string
)
$theClass
);
return
;
}
if
(
$name
!==
''
)
{
$this
->
setName
(
$name
);
}
else
{
$this
->
setName
(
$theClass
->
getName
());
}
$constructor
=
$theClass
->
getConstructor
();
if
(
$constructor
!==
null
&&
!
$constructor
->
isPublic
())
{
$this
->
addTest
(
new
WarningTestCase
(
sprintf
(
'Class "%s" has no public constructor.'
,
$theClass
->
getName
(),
),
),
);
return
;
}
foreach
((
new
Reflection
)->
publicMethodsInTestClass
(
$theClass
)
as
$method
)
{
if
(!
TestUtil
::
isTestMethod
(
$method
))
{
continue
;
}
$this
->
addTestMethod
(
$theClass
,
$method
);
}
if
(
empty
(
$this
->
tests
))
{
$this
->
addTest
(
new
WarningTestCase
(
sprintf
(
'No tests found in class "%s".'
,
$theClass
->
getName
(),
),
),
);
}
$this
->
testCase
=
true
;
}
/**
* Returns a string representation of the test suite.
*/
public
function
toString
():
string
{
return
$this
->
getName
();
}
/**
* Adds a test to the suite.
*
* @param array $groups
*/
public
function
addTest
(
Test
$test
,
$groups
=
[]):
void
{
try
{
$class
=
new
ReflectionClass
(
$test
);
// @codeCoverageIgnoreStart
}
catch
(
ReflectionException
$e
)
{
throw
new
Exception
(
$e
->
getMessage
(),
$e
->
getCode
(),
$e
,
);
}
// @codeCoverageIgnoreEnd
if
(!
$class
->
isAbstract
())
{
$this
->
tests
[]
=
$test
;
$this
->
clearCaches
();
if
(
$test
instanceof
self
&&
empty
(
$groups
))
{
$groups
=
$test
->
getGroups
();
}
if
(
$this
->
containsOnlyVirtualGroups
(
$groups
))
{
$groups
[]
=
'default'
;
}
foreach
(
$groups
as
$group
)
{
if
(!
isset
(
$this
->
groups
[
$group
]))
{
$this
->
groups
[
$group
]
=
[
$test
];
}
else
{
$this
->
groups
[
$group
][]
=
$test
;
}
}
if
(
$test
instanceof
TestCase
)
{
$test
->
setGroups
(
$groups
);
}
}
}
/**
* Adds the tests from the given class to the suite.
*
* @psalm-param object|class-string $testClass
*
* @throws Exception
*/
public
function
addTestSuite
(
$testClass
):
void
{
if
(!(
is_object
(
$testClass
)
||
(
is_string
(
$testClass
)
&&
class_exists
(
$testClass
))))
{
throw
InvalidArgumentException
::
create
(
1
,
'class name or object'
,
);
}
if
(!
is_object
(
$testClass
))
{
try
{
$testClass
=
new
ReflectionClass
(
$testClass
);
// @codeCoverageIgnoreStart
}
catch
(
ReflectionException
$e
)
{
throw
new
Exception
(
$e
->
getMessage
(),
$e
->
getCode
(),
$e
,
);
}
// @codeCoverageIgnoreEnd
}
if
(
$testClass
instanceof
self
)
{
$this
->
addTest
(
$testClass
);
}
elseif
(
$testClass
instanceof
ReflectionClass
)
{
$suiteMethod
=
false
;
if
(!
$testClass
->
isAbstract
()
&&
$testClass
->
hasMethod
(
BaseTestRunner
::
SUITE_METHODNAME
))
{
try
{
$method
=
$testClass
->
getMethod
(
BaseTestRunner
::
SUITE_METHODNAME
,
);
// @codeCoverageIgnoreStart
}
catch
(
ReflectionException
$e
)
{
throw
new
Exception
(
$e
->
getMessage
(),
$e
->
getCode
(),
$e
,
);
}
// @codeCoverageIgnoreEnd
if
(
$method
->
isStatic
())
{
$this
->
addTest
(
$method
->
invoke
(
null
,
$testClass
->
getName
()),
);
$suiteMethod
=
true
;
}
}
if
(!
$suiteMethod
&&
!
$testClass
->
isAbstract
()
&&
$testClass
->
isSubclassOf
(
TestCase
::
class
))
{
$this
->
addTest
(
new
self
(
$testClass
));
}
}
else
{
throw
new
Exception
;
}
}
public
function
addWarning
(
string
$warning
):
void
{
$this
->
warnings
[]
=
$warning
;
}
/**
* 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\WarningTestCase</code> will be created instead,
* leaving the current test run untouched.
*
* @throws Exception
*/
public
function
addTestFile
(
string
$filename
):
void
{
if
(
is_file
(
$filename
)
&&
substr
(
$filename
,
-
5
)
===
'.phpt'
)
{
$this
->
addTest
(
new
PhptTestCase
(
$filename
));
$this
->
declaredClassesPointer
=
count
(
get_declared_classes
());
return
;
}
$numTests
=
count
(
$this
->
tests
);
// The given file may contain further stub classes in addition to the
// test class itself. Figure out the actual test class.
$filename
=
FileLoader
::
checkAndLoad
(
$filename
);
$newClasses
=
array_slice
(
get_declared_classes
(),
$this
->
declaredClassesPointer
);
// The diff is empty in case a parent class (with test methods) is added
// AFTER a child class that inherited from it. To account for that case,
// accumulate all discovered classes, so the parent class may be found in
// a later invocation.
if
(!
empty
(
$newClasses
))
{
// On the assumption that test classes are defined first in files,
// process discovered classes in approximate LIFO order, so as to
// avoid unnecessary reflection.
$this
->
foundClasses
=
array_merge
(
$newClasses
,
$this
->
foundClasses
);
$this
->
declaredClassesPointer
=
count
(
get_declared_classes
());
}
// The test class's name must match the filename, either in full, or as
// a PEAR/PSR-0 prefixed short name ('NameSpace_ShortName'), or as a
// PSR-1 local short name ('NameSpace\ShortName'). The comparison must be
// anchored to prevent false-positive matches (e.g., 'OtherShortName').
$shortName
=
basename
(
$filename
,
'.php'
);
$shortNameRegEx
=
'/(?:^|_|
\\\\
)'
.
preg_quote
(
$shortName
,
'/'
)
.
'$/'
;
foreach
(
$this
->
foundClasses
as
$i
=>
$className
)
{
if
(
preg_match
(
$shortNameRegEx
,
$className
))
{
try
{
$class
=
new
ReflectionClass
(
$className
);
// @codeCoverageIgnoreStart
}
catch
(
ReflectionException
$e
)
{
throw
new
Exception
(
$e
->
getMessage
(),
$e
->
getCode
(),
$e
,
);
}
// @codeCoverageIgnoreEnd
if
(
$class
->
getFileName
()
==
$filename
)
{
$newClasses
=
[
$className
];
unset
(
$this
->
foundClasses
[
$i
]);
break
;
}
}
}
foreach
(
$newClasses
as
$className
)
{
try
{
$class
=
new
ReflectionClass
(
$className
);
// @codeCoverageIgnoreStart
}
catch
(
ReflectionException
$e
)
{
throw
new
Exception
(
$e
->
getMessage
(),
$e
->
getCode
(),
$e
,
);
}
// @codeCoverageIgnoreEnd
if
(
dirname
(
$class
->
getFileName
())
===
__DIR__
)
{
continue
;
}
if
(
$class
->
isAbstract
()
&&
$class
->
isSubclassOf
(
TestCase
::
class
))
{
$this
->
addWarning
(
sprintf
(
'Abstract test case classes with "Test" suffix are deprecated (%s)'
,
$class
->
getName
(),
),
);
}
if
(!
$class
->
isAbstract
())
{
if
(
$class
->
hasMethod
(
BaseTestRunner
::
SUITE_METHODNAME
))
{
try
{
$method
=
$class
->
getMethod
(
BaseTestRunner
::
SUITE_METHODNAME
,
);
// @codeCoverageIgnoreStart
}
catch
(
ReflectionException
$e
)
{
throw
new
Exception
(
$e
->
getMessage
(),
$e
->
getCode
(),
$e
,
);
}
// @codeCoverageIgnoreEnd
if
(
$method
->
isStatic
())
{
$this
->
addTest
(
$method
->
invoke
(
null
,
$className
));
}
}
elseif
(
$class
->
implementsInterface
(
Test
::
class
))
{
// Do we have modern namespacing ('Foo\Bar\WhizBangTest') or old-school namespacing ('Foo_Bar_WhizBangTest')?
$isPsr0
=
(!
$class
->
inNamespace
())
&&
(
strpos
(
$class
->
getName
(),
'_'
)
!==
false
);
$expectedClassName
=
$isPsr0
?
$className
:
$shortName
;
if
((
$pos
=
strpos
(
$expectedClassName
,
'.'
))
!==
false
)
{
$expectedClassName
=
substr
(
$expectedClassName
,
0
,
$pos
,
);
}
if
(
$class
->
getShortName
()
!==
$expectedClassName
)
{
$this
->
addWarning
(
sprintf
(
"Test case class not matching filename is deprecated
\n
in %s
\n
Class name was '%s', expected '%s'"
,
$filename
,
$class
->
getShortName
(),
$expectedClassName
,
),
);
}
$this
->
addTestSuite
(
$class
);
}
}
}
if
(
count
(
$this
->
tests
)
>
++
$numTests
)
{
$this
->
addWarning
(
sprintf
(
"Multiple test case classes per file is deprecated
\n
in %s"
,
$filename
,
),
);
}
$this
->
numTests
=
-
1
;
}
/**
* Wrapper for addTestFile() that adds multiple test files.
*
* @throws Exception
*/
public
function
addTestFiles
(
iterable
$fileNames
):
void
{
foreach
(
$fileNames
as
$filename
)
{
$this
->
addTestFile
((
string
)
$filename
);
}
}
/**
* Counts the number of test cases that will be run by this test.
*
* @todo refactor usage of numTests in DefaultResultPrinter
*/
public
function
count
():
int
{
$this
->
numTests
=
0
;
foreach
(
$this
as
$test
)
{
$this
->
numTests
+=
count
(
$test
);
}
return
$this
->
numTests
;
}
/**
* Returns the name of the suite.
*/
public
function
getName
():
string
{
return
$this
->
name
;
}
/**
* Returns the test groups of the suite.
*
* @psalm-return list<string>
*/
public
function
getGroups
():
array
{
return
array_map
(
static
function
(
$key
):
string
{
return
(
string
)
$key
;
},
array_keys
(
$this
->
groups
),
);
}
public
function
getGroupDetails
():
array
{
return
$this
->
groups
;
}
/**
* Set tests groups of the test case.
*/
public
function
setGroupDetails
(
array
$groups
):
void
{
$this
->
groups
=
$groups
;
}
/**
* Runs the tests and collects their result in a TestResult.
*
* @throws \SebastianBergmann\CodeCoverage\InvalidArgumentException
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
* @throws CodeCoverageException
* @throws UnintentionallyCoveredCodeException
* @throws Warning
*/
public
function
run
(?
TestResult
$result
=
null
):
TestResult
{
if
(
$result
===
null
)
{
$result
=
$this
->
createResult
();
}
if
(
count
(
$this
)
===
0
)
{
return
$result
;
}
/** @psalm-var class-string $className */
$className
=
$this
->
name
;
$hookMethods
=
TestUtil
::
getHookMethods
(
$className
);
$result
->
startTestSuite
(
$this
);
$test
=
null
;
if
(
$this
->
testCase
&&
class_exists
(
$this
->
name
,
false
))
{
try
{
foreach
(
$hookMethods
[
'beforeClass'
]
as
$beforeClassMethod
)
{
if
(
method_exists
(
$this
->
name
,
$beforeClassMethod
))
{
if
(
$missingRequirements
=
TestUtil
::
getMissingRequirements
(
$this
->
name
,
$beforeClassMethod
))
{
$this
->
markTestSuiteSkipped
(
implode
(
PHP_EOL
,
$missingRequirements
));
}
call_user_func
([
$this
->
name
,
$beforeClassMethod
]);
}
}
}
catch
(
SkippedTestError
|
SkippedTestSuiteError
$error
)
{
foreach
(
$this
->
tests
()
as
$test
)
{
$result
->
startTest
(
$test
);
$result
->
addFailure
(
$test
,
$error
,
0
);
$result
->
endTest
(
$test
,
0
);
}
$result
->
endTestSuite
(
$this
);
return
$result
;
}
catch
(
Throwable
$t
)
{
$errorAdded
=
false
;
foreach
(
$this
->
tests
()
as
$test
)
{
if
(
$result
->
shouldStop
())
{
break
;
}
$result
->
startTest
(
$test
);
if
(!
$errorAdded
)
{
$result
->
addError
(
$test
,
$t
,
0
);
$errorAdded
=
true
;
}
else
{
$result
->
addFailure
(
$test
,
new
SkippedTestError
(
'Test skipped because of an error in hook method'
),
0
,
);
}
$result
->
endTest
(
$test
,
0
);
}
$result
->
endTestSuite
(
$this
);
return
$result
;
}
}
foreach
(
$this
as
$test
)
{
if
(
$result
->
shouldStop
())
{
break
;
}
if
(
$test
instanceof
TestCase
||
$test
instanceof
self
)
{
$test
->
setBeStrictAboutChangesToGlobalState
(
$this
->
beStrictAboutChangesToGlobalState
);
$test
->
setBackupGlobals
(
$this
->
backupGlobals
);
$test
->
setBackupStaticAttributes
(
$this
->
backupStaticAttributes
);
$test
->
setRunTestInSeparateProcess
(
$this
->
runTestInSeparateProcess
);
}
$test
->
run
(
$result
);
}
if
(
$this
->
testCase
&&
class_exists
(
$this
->
name
,
false
))
{
foreach
(
$hookMethods
[
'afterClass'
]
as
$afterClassMethod
)
{
if
(
method_exists
(
$this
->
name
,
$afterClassMethod
))
{
try
{
call_user_func
([
$this
->
name
,
$afterClassMethod
]);
}
catch
(
Throwable
$t
)
{
$message
=
"Exception in {$this->name}::{$afterClassMethod}"
.
PHP_EOL
.
$t
->
getMessage
();
$error
=
new
SyntheticError
(
$message
,
0
,
$t
->
getFile
(),
$t
->
getLine
(),
$t
->
getTrace
());
$placeholderTest
=
clone
$test
;
$placeholderTest
->
setName
(
$afterClassMethod
);
$result
->
startTest
(
$placeholderTest
);
$result
->
addFailure
(
$placeholderTest
,
$error
,
0
);
$result
->
endTest
(
$placeholderTest
,
0
);
}
}
}
}
$result
->
endTestSuite
(
$this
);
return
$result
;
}
public
function
setRunTestInSeparateProcess
(
bool
$runTestInSeparateProcess
):
void
{
$this
->
runTestInSeparateProcess
=
$runTestInSeparateProcess
;
}
public
function
setName
(
string
$name
):
void
{
$this
->
name
=
$name
;
}
/**
* Returns the tests as an enumeration.
*
* @return Test[]
*/
public
function
tests
():
array
{
return
$this
->
tests
;
}
/**
* Set tests of the test suite.
*
* @param Test[] $tests
*/
public
function
setTests
(
array
$tests
):
void
{
$this
->
tests
=
$tests
;
}
/**
* Mark the test suite as skipped.
*
* @param string $message
*
* @throws SkippedTestSuiteError
*
* @psalm-return never-return
*/
public
function
markTestSuiteSkipped
(
$message
=
''
):
void
{
throw
new
SkippedTestSuiteError
(
$message
);
}
/**
* @param bool $beStrictAboutChangesToGlobalState
*/
public
function
setBeStrictAboutChangesToGlobalState
(
$beStrictAboutChangesToGlobalState
):
void
{
if
(
null
===
$this
->
beStrictAboutChangesToGlobalState
&&
is_bool
(
$beStrictAboutChangesToGlobalState
))
{
$this
->
beStrictAboutChangesToGlobalState
=
$beStrictAboutChangesToGlobalState
;
}
}
/**
* @param bool $backupGlobals
*/
public
function
setBackupGlobals
(
$backupGlobals
):
void
{
if
(
null
===
$this
->
backupGlobals
&&
is_bool
(
$backupGlobals
))
{
$this
->
backupGlobals
=
$backupGlobals
;
}
}
/**
* @param bool $backupStaticAttributes
*/
public
function
setBackupStaticAttributes
(
$backupStaticAttributes
):
void
{
if
(
null
===
$this
->
backupStaticAttributes
&&
is_bool
(
$backupStaticAttributes
))
{
$this
->
backupStaticAttributes
=
$backupStaticAttributes
;
}
}
/**
* Returns an iterator for this test suite.
*/
public
function
getIterator
():
Iterator
{
$iterator
=
new
TestSuiteIterator
(
$this
);
if
(
$this
->
iteratorFilter
!==
null
)
{
$iterator
=
$this
->
iteratorFilter
->
factory
(
$iterator
,
$this
);
}
return
$iterator
;
}
public
function
injectFilter
(
Factory
$filter
):
void
{
$this
->
iteratorFilter
=
$filter
;
foreach
(
$this
as
$test
)
{
if
(
$test
instanceof
self
)
{
$test
->
injectFilter
(
$filter
);
}
}
}
/**
* @psalm-return array<int,string>
*/
public
function
warnings
():
array
{
return
array_unique
(
$this
->
warnings
);
}
/**
* @return list<ExecutionOrderDependency>
*/
public
function
provides
():
array
{
if
(
$this
->
providedTests
===
null
)
{
$this
->
providedTests
=
[];
if
(
is_callable
(
$this
->
sortId
(),
true
))
{
$this
->
providedTests
[]
=
new
ExecutionOrderDependency
(
$this
->
sortId
());
}
foreach
(
$this
->
tests
as
$test
)
{
if
(!(
$test
instanceof
Reorderable
))
{
// @codeCoverageIgnoreStart
continue
;
// @codeCoverageIgnoreEnd
}
$this
->
providedTests
=
ExecutionOrderDependency
::
mergeUnique
(
$this
->
providedTests
,
$test
->
provides
());
}
}
return
$this
->
providedTests
;
}
/**
* @return list<ExecutionOrderDependency>
*/
public
function
requires
():
array
{
if
(
$this
->
requiredTests
===
null
)
{
$this
->
requiredTests
=
[];
foreach
(
$this
->
tests
as
$test
)
{
if
(!(
$test
instanceof
Reorderable
))
{
// @codeCoverageIgnoreStart
continue
;
// @codeCoverageIgnoreEnd
}
$this
->
requiredTests
=
ExecutionOrderDependency
::
mergeUnique
(
ExecutionOrderDependency
::
filterInvalid
(
$this
->
requiredTests
),
$test
->
requires
(),
);
}
$this
->
requiredTests
=
ExecutionOrderDependency
::
diff
(
$this
->
requiredTests
,
$this
->
provides
());
}
return
$this
->
requiredTests
;
}
public
function
sortId
():
string
{
return
$this
->
getName
()
.
'::class'
;
}
/**
* Creates a default TestResult object.
*/
protected
function
createResult
():
TestResult
{
return
new
TestResult
;
}
/**
* @throws Exception
*/
protected
function
addTestMethod
(
ReflectionClass
$class
,
ReflectionMethod
$method
):
void
{
$methodName
=
$method
->
getName
();
$test
=
(
new
TestBuilder
)->
build
(
$class
,
$methodName
);
if
(
$test
instanceof
TestCase
||
$test
instanceof
DataProviderTestSuite
)
{
$test
->
setDependencies
(
TestUtil
::
getDependencies
(
$class
->
getName
(),
$methodName
),
);
}
$this
->
addTest
(
$test
,
TestUtil
::
getGroups
(
$class
->
getName
(),
$methodName
),
);
}
private
function
clearCaches
():
void
{
$this
->
numTests
=
-
1
;
$this
->
providedTests
=
null
;
$this
->
requiredTests
=
null
;
}
private
function
containsOnlyVirtualGroups
(
array
$groups
):
bool
{
foreach
(
$groups
as
$group
)
{
if
(
strpos
(
$group
,
'__phpunit_'
)
!==
0
)
{
return
false
;
}
}
return
true
;
}
}
File Metadata
Details
Attached
Mime Type
text/x-php
Expires
Sun, Nov 22, 02:13 (1 d, 13 h)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
01/f3/2bf8702df87e871904c69bd487e6
Default Alt Text
TestSuite.php (26 KB)
Attached To
Mode
rMWPROD MediaWiki Production
Attached
Detach File
Event Timeline
Log In to Comment