664 lines
13 KiB
PHP
664 lines
13 KiB
PHP
<?php // phpcs:disable Generic.Files.LineLength
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace tests;
|
|
|
|
use PHPUnit\Framework\TestCase;
|
|
use CoreLibs\Debug\Support;
|
|
|
|
/**
|
|
* Test class for Debug\Support
|
|
* @coversDefaultClass \CoreLibs\Debug\Support
|
|
* @testdox \CoreLibs\Debug\Support method tests
|
|
*/
|
|
final class CoreLibsDebugSupportTest extends TestCase
|
|
{
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @return array
|
|
*/
|
|
public function printTimeProvider(): array
|
|
{
|
|
return [
|
|
'default microtime' => [
|
|
0 => null,
|
|
1 => "/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}.\d{8}$/",
|
|
],
|
|
'microtime -1' => [
|
|
0 => -1,
|
|
1 => "/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}.\d{8}$/",
|
|
],
|
|
'microtime 0' => [
|
|
0 => 0,
|
|
1 => "/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/",
|
|
],
|
|
'microtime 4' => [
|
|
0 => 4,
|
|
1 => "/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}.\d{4}$/",
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::printTime
|
|
* @dataProvider printTimeProvider
|
|
* @testdox printTime test with $microtime and match to regex [$_dataName]
|
|
*
|
|
* @param int|null $mircrotime
|
|
* @param string $expected
|
|
* @return void
|
|
*/
|
|
public function testPrintTime(?int $microtime, string $regex): void
|
|
{
|
|
if ($microtime === null) {
|
|
$this->assertMatchesRegularExpression(
|
|
$regex,
|
|
Support::printTime()
|
|
);
|
|
} else {
|
|
$this->assertMatchesRegularExpression(
|
|
$regex,
|
|
Support::printTime($microtime)
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @return array
|
|
*/
|
|
public function printArrayProvider(): array
|
|
{
|
|
return [
|
|
'empty array' => [
|
|
0 => [],
|
|
1 => "<pre>Array\n(\n)\n</pre>",
|
|
2 => "Array\n(\n)\n",
|
|
],
|
|
'simple array' => [
|
|
0 => ['a', 'b'],
|
|
1 => "<pre>Array\n(\n"
|
|
. " [0] => a\n"
|
|
. " [1] => b\n"
|
|
. ")\n</pre>",
|
|
2 => "Array\n(\n"
|
|
. " [0] => a\n"
|
|
. " [1] => b\n"
|
|
. ")\n",
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::printAr
|
|
* @cover ::printArray
|
|
* @dataProvider printArrayProvider
|
|
* @testdox printAr/printArray $input will be $expected [$_dataName]
|
|
*
|
|
* @param array $input
|
|
* @param string $expected
|
|
* @param string $expected_strip
|
|
* @return void
|
|
*/
|
|
public function testPrintAr(array $input, string $expected, string $expected_strip): void
|
|
{
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::printAr($input),
|
|
'assert printAr'
|
|
);
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::printArray($input),
|
|
'assert printArray'
|
|
);
|
|
$this->assertEquals(
|
|
$expected_strip,
|
|
Support::prAr($input),
|
|
'assert prAr'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @return array
|
|
*/
|
|
public function printBoolProvider(): array
|
|
{
|
|
return [
|
|
'true input default' => [
|
|
0 => true,
|
|
1 => [],
|
|
2 => 'true',
|
|
3 => 'true',
|
|
],
|
|
'false input default' => [
|
|
0 => false,
|
|
1 => [],
|
|
2 => 'false',
|
|
3 => 'false'
|
|
],
|
|
'false input param name' => [
|
|
0 => false,
|
|
1 => [
|
|
'name' => 'param test'
|
|
],
|
|
2 => '<b>param test</b>: false',
|
|
3 => 'false'
|
|
],
|
|
'true input param name, true override' => [
|
|
0 => true,
|
|
1 => [
|
|
'name' => 'param test',
|
|
'true' => 'ok',
|
|
],
|
|
2 => '<b>param test</b>: ok',
|
|
3 => 'ok',
|
|
],
|
|
'false input param name, true override, false override' => [
|
|
0 => false,
|
|
1 => [
|
|
'name' => 'param test',
|
|
'true' => 'ok',
|
|
'false' => 'not',
|
|
],
|
|
2 => '<b>param test</b>: not',
|
|
3 => 'not'
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::printBool
|
|
* @dataProvider printBoolProvider
|
|
* @testdox printBool $input will be $expected [$_dataName]
|
|
*
|
|
* @param bool $input
|
|
* @param array $params
|
|
* @param string $expected
|
|
* @param string $expected_strip
|
|
* @return void
|
|
*/
|
|
public function testPrintBool(bool $input, array $params, string $expected, string $expected_strip): void
|
|
{
|
|
if (
|
|
isset($params['name']) &&
|
|
isset($params['true']) &&
|
|
isset($params['false'])
|
|
) {
|
|
$string = Support::printBool(
|
|
$input,
|
|
$params['name'],
|
|
$params['true'],
|
|
$params['false']
|
|
);
|
|
$string_strip = Support::prBl(
|
|
$input,
|
|
$params['true'],
|
|
$params['false']
|
|
);
|
|
} elseif (isset($params['name']) && isset($params['true'])) {
|
|
$string = Support::printBool(
|
|
$input,
|
|
$params['name'],
|
|
$params['true']
|
|
);
|
|
$string_strip = Support::prBl(
|
|
$input,
|
|
$params['true'],
|
|
);
|
|
} elseif (isset($params['name'])) {
|
|
$string = Support::printBool(
|
|
$input,
|
|
$params['name']
|
|
);
|
|
$string_strip = Support::prBl(
|
|
$input
|
|
);
|
|
} else {
|
|
$string = Support::printBool($input);
|
|
$string_strip = Support::prBl($input);
|
|
}
|
|
$this->assertEquals(
|
|
$expected,
|
|
$string,
|
|
'assert printBool'
|
|
);
|
|
$this->assertEquals(
|
|
$expected_strip,
|
|
$string_strip,
|
|
'assert prBl'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @return array
|
|
*/
|
|
public function printToStringProvider(): array
|
|
{
|
|
// 0: unput
|
|
// 1: html flag (only for strings and arry)
|
|
// 2: expected
|
|
return [
|
|
'null' => [
|
|
null,
|
|
null,
|
|
'NULL',
|
|
],
|
|
'string' => [
|
|
'a string',
|
|
null,
|
|
'a string',
|
|
],
|
|
'string with html chars, encode' => [
|
|
'a string with <> &',
|
|
true,
|
|
'a string with <> &',
|
|
],
|
|
'string with html chars' => [
|
|
'a string with <> &',
|
|
null,
|
|
'a string with <> &',
|
|
],
|
|
'a number' => [
|
|
1234,
|
|
null,
|
|
'1234',
|
|
],
|
|
'a float number' => [
|
|
1234.5678,
|
|
null,
|
|
'1234.5678',
|
|
],
|
|
'bool true' => [
|
|
true,
|
|
null,
|
|
'TRUE',
|
|
],
|
|
'bool false' => [
|
|
false,
|
|
null,
|
|
'FALSE',
|
|
],
|
|
'an array default' => [
|
|
['a', 'b'],
|
|
null,
|
|
"<pre>Array\n(\n"
|
|
. " [0] => a\n"
|
|
. " [1] => b\n"
|
|
. ")\n</pre>",
|
|
],
|
|
'an array, no html' => [
|
|
['a', 'b'],
|
|
true,
|
|
"Array\n(\n"
|
|
. " [0] => a\n"
|
|
. " [1] => b\n"
|
|
. ")\n",
|
|
],
|
|
// resource
|
|
'a resource' => [
|
|
tmpfile(),
|
|
null,
|
|
'/^Resource id #\d+$/',
|
|
],
|
|
// object
|
|
'an object' => [
|
|
new \CoreLibs\Debug\Support(),
|
|
null,
|
|
'CoreLibs\Debug\Support',
|
|
]
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::printToString
|
|
* @dataProvider printToStringProvider
|
|
* @testdox printToString $input with $flag will be $expected [$_dataName]
|
|
*
|
|
* @param mixed $input anything
|
|
* @param boolean|null $flag html flag, only for string and array
|
|
* @param string $expected always string
|
|
* @return void
|
|
*/
|
|
public function testPrintToString(mixed $input, ?bool $flag, string $expected): void
|
|
{
|
|
if ($flag === null) {
|
|
// if expected starts with / and ends with / then this is a regex compare
|
|
if (
|
|
substr($expected, 0, 1) == '/' &&
|
|
substr($expected, -1, 1) == '/'
|
|
) {
|
|
$this->assertMatchesRegularExpression(
|
|
$expected,
|
|
Support::printToString($input)
|
|
);
|
|
} else {
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::printToString($input)
|
|
);
|
|
}
|
|
} else {
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::printToString($input, $flag)
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @return array
|
|
*/
|
|
public function providerDumpExportVar(): array
|
|
{
|
|
return [
|
|
'string' => [
|
|
'input' => 'string',
|
|
'flag' => null,
|
|
'expected_dump' => 'string(6) "string"' . "\n",
|
|
'expected_export' => "<pre>'string'</pre>",
|
|
],
|
|
'string, no html' => [
|
|
'input' => 'string',
|
|
'flag' => true,
|
|
'expected_dump' => 'string(6) "string"' . "\n",
|
|
'expected_export' => "'string'",
|
|
],
|
|
// int
|
|
'int' => [
|
|
'input' => 6,
|
|
'flag' => null,
|
|
'expected_dump' => 'int(6)' . "\n",
|
|
'expected_export' => "<pre>6</pre>",
|
|
],
|
|
// float
|
|
'float' => [
|
|
'input' => 1.6,
|
|
'flag' => null,
|
|
'expected_dump' => 'float(1.6)' . "\n",
|
|
'expected_export' => "<pre>1.6</pre>",
|
|
],
|
|
// bool
|
|
'bool' => [
|
|
'input' => true,
|
|
'flag' => null,
|
|
'expected_dump' => 'bool(true)' . "\n",
|
|
'expected_export' => "<pre>true</pre>",
|
|
],
|
|
// array
|
|
'array' => [
|
|
'input' => ['string', true],
|
|
'flag' => null,
|
|
'expected_dump' => "array(2) {\n"
|
|
. " [0]=>\n"
|
|
. " string(6) \"string\"\n"
|
|
. " [1]=>\n"
|
|
. " bool(true)\n"
|
|
. "}\n",
|
|
'expected_export' => "<pre>array (\n"
|
|
. " 0 => 'string',\n"
|
|
. " 1 => true,\n"
|
|
. ")</pre>",
|
|
],
|
|
// more
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::dumpVar
|
|
* @cover ::exportVar
|
|
* @dataProvider providerDumpExportVar
|
|
* @testdox dump/exportVar $input with $flag will be $expected_dump / $expected_export [$_dataName]
|
|
*
|
|
* @param mixed $input
|
|
* @param bool|null $flag
|
|
* @param string $expected_dump
|
|
* @param string $expected_export
|
|
* @return void
|
|
*/
|
|
public function testDumpExportVar(mixed $input, ?bool $flag, string $expected_dump, string $expected_export): void
|
|
{
|
|
if ($flag === null) {
|
|
$dump = Support::dumpVar($input);
|
|
$export = Support::exportVar($input);
|
|
} else {
|
|
$dump = Support::dumpVar($input, $flag);
|
|
$export = Support::exportVar($input, $flag);
|
|
}
|
|
$this->assertEquals(
|
|
$expected_dump,
|
|
$dump,
|
|
'assert dumpVar'
|
|
);
|
|
$this->assertEquals(
|
|
$expected_export,
|
|
$export,
|
|
'assert dumpVar'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::getCallerFileLine
|
|
* @testWith ["vendor/phpunit/phpunit/src/Framework/TestCase.php:"]
|
|
* @testdox getCallerFileLine check based on regex /[\w\-\/]/vendor/phpunit/phpunit/src/Framework/TestCase.php:\d+ [$_dataName]
|
|
*
|
|
* @param string $expected
|
|
* @return void
|
|
*/
|
|
public function testGetCallerFileLine(): void
|
|
{
|
|
// regex prefix with path "/../" and then fixed vendor + \d+
|
|
$regex = "/^\/[\w\-\/]+\/vendor\/phpunit\/phpunit\/src\/Framework\/TestCase.php:\d+$/";
|
|
$this->assertMatchesRegularExpression(
|
|
$regex,
|
|
Support::getCallerFileLine()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::getCallerMethod
|
|
* @testWith ["testGetCallerMethod"]
|
|
* @testdox getCallerMethod check if it returns $expected [$_dataName]
|
|
*
|
|
* @return void
|
|
*/
|
|
public function testGetCallerMethod(string $expected): void
|
|
{
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::getCallerMethod()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::getCallerMethodList
|
|
* @testWith [["main", "run", "run", "run", "run", "run", "run", "runBare", "runTest", "testGetCallerMethodList"]]
|
|
* @testdox getCallerMethodList check if it returns $expected [$_dataName]
|
|
*
|
|
* @param array $expected
|
|
* @return void
|
|
*/
|
|
public function testGetCallerMethodList(array $expected): void
|
|
{
|
|
$compare = Support::getCallerMethodList();
|
|
// 10: legact
|
|
// 11: direct
|
|
// 12: full call
|
|
switch (count($compare)) {
|
|
case 10:
|
|
// add nothing
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::getCallerMethodList(),
|
|
'assert expected 10'
|
|
);
|
|
break;
|
|
case 11:
|
|
// add one "run" before "runBare"
|
|
// array_splice(
|
|
// $expected,
|
|
// 7,
|
|
// 0,
|
|
// ['run']
|
|
// );
|
|
array_splice(
|
|
$expected,
|
|
0,
|
|
0,
|
|
['include']
|
|
);
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::getCallerMethodList(),
|
|
'assert expected 11'
|
|
);
|
|
break;
|
|
case 12:
|
|
// add two "run" before "runBare"
|
|
array_splice(
|
|
$expected,
|
|
7,
|
|
0,
|
|
['run']
|
|
);
|
|
array_splice(
|
|
$expected,
|
|
0,
|
|
0,
|
|
['include']
|
|
);
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::getCallerMethodList(),
|
|
'assert expected 12'
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::getCallerClass
|
|
* @testWith ["PHPUnit\\TextUI\\Command"]
|
|
* @testdox getCallerClass check if it returns $expected [$_dataName]
|
|
*
|
|
* @return void
|
|
*/
|
|
public function testGetCallerClass(string $expected): void
|
|
{
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::getCallerClass()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @return array
|
|
*/
|
|
public function debugStringProvider(): array
|
|
{
|
|
// 0: input string
|
|
// 1: replace
|
|
// 2: html flag
|
|
// 3: expected
|
|
return [
|
|
'null string, default' => [
|
|
null,
|
|
null,
|
|
null,
|
|
'-'
|
|
],
|
|
'empty string, ... replace' => [
|
|
'',
|
|
'...',
|
|
null,
|
|
'...'
|
|
],
|
|
'filled string' => [
|
|
'some string',
|
|
null,
|
|
null,
|
|
'some string'
|
|
],
|
|
'string with html chars, encode' => [
|
|
'a string with <> &',
|
|
'-',
|
|
true,
|
|
'a string with <> &',
|
|
],
|
|
'string with html chars' => [
|
|
'a string with <> &',
|
|
'-',
|
|
null,
|
|
'a string with <> &',
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Undocumented function
|
|
*
|
|
* @cover ::debugString
|
|
* @dataProvider debugStringProvider
|
|
* @testdox debugString $input with replace $replace and html $flag will be $expected [$_dataName]
|
|
*
|
|
* @param string|null $input
|
|
* @param string|null $replace
|
|
* @param bool|null $flag
|
|
* @param string $expected
|
|
* @return void
|
|
*/
|
|
public function testDebugString(?string $input, ?string $replace, ?bool $flag, string $expected): void
|
|
{
|
|
if ($replace === null && $flag === null) {
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::debugString($input),
|
|
'assert all default'
|
|
);
|
|
} elseif ($flag === null) {
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::debugString($input, $replace),
|
|
'assert flag default'
|
|
);
|
|
} else {
|
|
$this->assertEquals(
|
|
$expected,
|
|
Support::debugString($input, $replace, $flag),
|
|
'assert all set'
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// __END__
|