Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
52.94% |
9 / 17 |
CRAP | |
89.33% |
67 / 75 |
| Inspector | |
0.00% |
0 / 1 |
|
52.94% |
9 / 17 |
57.54 | |
89.33% |
67 / 75 |
| assertTraversable | |
100.00% |
1 / 1 |
2 | |
100.00% |
1 / 1 |
|||
| assertAll | |
0.00% |
0 / 1 |
4.07 | |
83.33% |
5 / 6 |
|||
| assertAllStrings | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| assertAllStringable | |
100.00% |
1 / 1 |
4 | |
100.00% |
6 / 6 |
|||
| assertStringable | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 1 |
|||
| assertAllArrays | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| assertStrictArray | |
0.00% |
0 / 1 |
4.03 | |
87.50% |
7 / 8 |
|||
| assertAllStrictArrays | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| assertAllHaveKey | |
0.00% |
0 / 1 |
5.03 | |
88.89% |
8 / 9 |
|||
| assertAllIntegers | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| assertAllFloat | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| assertAllCallable | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| assertAllNotEmpty | |
0.00% |
0 / 1 |
4.07 | |
83.33% |
5 / 6 |
|||
| assertAllNumeric | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| assertAllMatch | |
0.00% |
0 / 1 |
9.08 | |
90.00% |
9 / 10 |
|||
| assertAllRegularExpressionMatch | |
0.00% |
0 / 1 |
5.05 | |
87.50% |
7 / 8 |
|||
| assertAllObjects | |
0.00% |
0 / 1 |
7.02 | |
92.31% |
12 / 13 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\Component\Assertion\Inspector. | |
| */ | |
| namespace Drupal\Component\Assertion; | |
| use Traversable; | |
| /** | |
| * Generic inspections for the assert() statement. | |
| * | |
| * This is a static function collection for inspecting variable contents. All | |
| * functions in this collection check a variable against an assertion about its | |
| * structure. | |
| * | |
| * Example call: | |
| * @code | |
| * assert('Drupal\\Component\\Assertion\\Inspector::assertAllStrings($array)'); | |
| * @endcode | |
| * | |
| * @ingroup php_assert | |
| */ | |
| class Inspector { | |
| /** | |
| * Asserts argument can be traversed with foreach. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed with foreach. | |
| */ | |
| public static function assertTraversable($traversable) { | |
| return is_array($traversable) || $traversable instanceof Traversable; | |
| } | |
| /** | |
| * Asserts callback returns TRUE for each member of a traversable. | |
| * | |
| * This is less memory intensive than using array_filter() to build a second | |
| * array and then comparing the arrays. Many of the other functions in this | |
| * collection alias this function passing a specific callback to make the | |
| * code more readable. | |
| * | |
| * @param callable $callable | |
| * Callback function. | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and $callable returns TRUE on | |
| * all members. | |
| * | |
| * @see http://php.net/manual/language.types.callable.php | |
| */ | |
| public static function assertAll(callable $callable, $traversable) { | |
| if (static::assertTraversable($traversable)) { | |
| foreach ($traversable as $member) { | |
| if (!$callable($member)) { | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| * Asserts that all members are strings. | |
| * | |
| * Use this only if it is vital that the members not be objects, otherwise | |
| * test with ::assertAllStringable(). | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are strings. | |
| */ | |
| public static function assertAllStrings($traversable) { | |
| return static::assertAll('is_string', $traversable); | |
| } | |
| /** | |
| * Asserts all members are strings or objects with magic __toString() method. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are strings or | |
| * objects with __toString(). | |
| */ | |
| public static function assertAllStringable($traversable) { | |
| if (static::assertTraversable($traversable)) { | |
| foreach ($traversable as $member) { | |
| if (!static::assertStringable($member)) { | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| * Asserts argument is a string or an object castable to a string. | |
| * | |
| * Use this instead of is_string() alone unless the argument being an object | |
| * in any way will cause a problem. | |
| * | |
| * @param mixed string | |
| * Variable to be examined | |
| * | |
| * @return bool | |
| * TRUE if $string is a string or an object castable to a string. | |
| */ | |
| public static function assertStringable($string) { | |
| return is_string($string) || (is_object($string) && method_exists($string, '__toString')); | |
| } | |
| /** | |
| * Asserts that all members are arrays. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are arrays. | |
| */ | |
| public static function assertAllArrays($traversable) { | |
| return static::assertAll('is_array', $traversable); | |
| } | |
| /** | |
| * Asserts that the array is strict. | |
| * | |
| * What PHP calls arrays are more formally called maps in most other | |
| * programming languages. A map is a datatype that associates values to keys. | |
| * The term 'strict array' here refers to a 0-indexed array in the classic | |
| * sense found in programming languages other than PHP. | |
| * | |
| * @param mixed $array | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable is a 0-indexed array. | |
| * | |
| * @see http://php.net/manual/language.types.array.php | |
| */ | |
| public static function assertStrictArray($array) { | |
| if (!is_array($array)) { | |
| return FALSE; | |
| } | |
| $i = 0; | |
| foreach (array_keys($array) as $key) { | |
| if ($i !== $key) { | |
| return FALSE; | |
| } | |
| $i++; | |
| } | |
| return TRUE; | |
| } | |
| /** | |
| * Asserts all members are strict arrays. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are strict arrays. | |
| * | |
| * @see ::assertStrictArray | |
| */ | |
| public static function assertAllStrictArrays($traversable) { | |
| return static::assertAll([__CLASS__, 'assertStrictArray'], $traversable); | |
| } | |
| /** | |
| * Asserts all given keys exist in every member array. | |
| * | |
| * Drupal has several data structure arrays that require certain keys be set. | |
| * You can overload this function to specify a list of required keys. All | |
| * of the keys must be set for this method to return TRUE. | |
| * | |
| * As an example, this assertion tests for the keys of a theme registry. | |
| * | |
| * @code | |
| * assert('Drupal\\Component\\Assertion\\Inspector::assertAllHaveKey( | |
| * $arrayToTest, "type", "theme path", "function", "template", "variables", "render element", "preprocess functions")'); | |
| * @endcode | |
| * | |
| * Note: If a method requires certain keys to be present it will usually be | |
| * specific about the data types for the values of those keys. Therefore it | |
| * will be best to write a specific test for it. Such tests are either bound | |
| * to the object that uses them, or are collected into one assertion set for | |
| * the package. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * @param string ... | |
| * Keys to be searched for. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members have all keys. | |
| */ | |
| public static function assertAllHaveKey() { | |
| $args = func_get_args(); | |
| $traversable = array_shift($args); | |
| if (static::assertTraversable($traversable)) { | |
| foreach ($traversable as $member) { | |
| foreach ($args as $key) { | |
| if (!array_key_exists($key, $member)) { | |
| return FALSE; | |
| } | |
| } | |
| } | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| * Asserts that all members are integer values. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are integers. | |
| */ | |
| public static function assertAllIntegers($traversable) { | |
| return static::assertAll('is_int', $traversable); | |
| } | |
| /** | |
| * Asserts that all members are float values. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are floating point | |
| * numbers. | |
| */ | |
| public static function assertAllFloat($traversable) { | |
| return static::assertAll('is_float', $traversable); | |
| } | |
| /** | |
| * Asserts that all members are callable. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are callable. | |
| */ | |
| public static function assertAllCallable($traversable) { | |
| return static::assertAll('is_callable', $traversable); | |
| } | |
| /** | |
| * Asserts that all members are not empty. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members not empty. | |
| */ | |
| public static function assertAllNotEmpty($traversable) { | |
| if (static::assertTraversable($traversable)) { | |
| foreach ($traversable as $member) { | |
| if (empty($member)) { | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| * Asserts all members are numeric data types or strings castable to such. | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are numeric. | |
| */ | |
| public static function assertAllNumeric($traversable) { | |
| return static::assertAll('is_numeric', $traversable); | |
| } | |
| /** | |
| * Asserts that all members are strings that contain the specified string. | |
| * | |
| * This runs faster than the regular expression equivalent. | |
| * | |
| * @param string $pattern | |
| * The needle to find. | |
| * @param mixed $traversable | |
| * Variable to examine. | |
| * @param bool $case_sensitive | |
| * TRUE to use strstr(), FALSE to use stristr() which is case insensitive. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are strings | |
| * containing $pattern. | |
| */ | |
| public static function assertAllMatch($pattern, $traversable, $case_sensitive = FALSE) { | |
| if (static::assertTraversable($traversable)) { | |
| if ($case_sensitive) { | |
| foreach ($traversable as $member) { | |
| if (!(is_string($member) && strstr($member, $pattern))) { | |
| return FALSE; | |
| } | |
| } | |
| } | |
| else { | |
| foreach ($traversable as $member) { | |
| if (!(is_string($member) && stristr($member, $pattern))) { | |
| return FALSE; | |
| } | |
| } | |
| } | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| * Asserts that all members are strings matching a regular expression. | |
| * | |
| * @param string $pattern | |
| * Regular expression string to find. | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are strings | |
| * matching $pattern. | |
| */ | |
| public static function assertAllRegularExpressionMatch($pattern, $traversable) { | |
| if (static::assertTraversable($traversable)) { | |
| foreach ($traversable as $member) { | |
| if (!is_string($member)) { | |
| return FALSE; | |
| } | |
| if (!preg_match($pattern, $member)) { | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| * Asserts that all members are objects. | |
| * | |
| * When testing if a collection is composed of objects those objects should | |
| * be given a common interface to implement and the test should be written to | |
| * search for just that interface. While this method will allow tests for | |
| * just object status or for multiple classes and interfaces this was done to | |
| * allow tests to be written for existing code without altering it. Only use | |
| * this method in that manner when testing code from third party vendors. | |
| * | |
| * Here are some examples: | |
| * @code | |
| * // Just test all are objects, like a cache. | |
| * assert('Drupal\\Component\\Assertion\\Inspector::assertAllObjects( | |
| * $collection'); | |
| * | |
| * // Test if traversable objects (arrays won't pass this) | |
| * assert('Drupal\\Component\\Assertion\\Inspector::assertAllObjects( | |
| * $collection', \'\\Traversable\'); | |
| * | |
| * // Test for the Foo class or Bar\None interface | |
| * assert('Drupal\\Component\\Assertion\\Inspector::assertAllObjects( | |
| * $collection', \'\\Foo\', \'\\Bar\\None\''); | |
| * @endcode | |
| * | |
| * @param mixed $traversable | |
| * Variable to be examined. | |
| * @param string ... | |
| * Classes and interfaces to test objects against. | |
| * | |
| * @return bool | |
| * TRUE if $traversable can be traversed and all members are objects with | |
| * at least one of the listed classes or interfaces. | |
| */ | |
| public static function assertAllObjects() { | |
| $args = func_get_args(); | |
| $traversable = array_shift($args); | |
| if (static::assertTraversable($traversable)) { | |
| foreach ($traversable as $member) { | |
| if (count($args) > 0) { | |
| foreach ($args as $instance) { | |
| if ($member instanceof $instance) { | |
| // We're continuing to the next member on the outer loop. | |
| // @see http://php.net/continue | |
| continue 2; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| elseif (!is_object($member)) { | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| } |