Move all tests into sub folders for a more clear structure
This commit is contained in:
Clemens Schwaighofer
176
4dev/tests/Debug/CoreLibsDebugFileWriterTest.php
Normal file
176
4dev/tests/Debug/CoreLibsDebugFileWriterTest.php
Normal file
@@ -0,0 +1,176 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* Test class for Debug\FileWriter
|
||||
* @coversDefaultClass \CoreLibs\Debug\FileWriter
|
||||
* @testdox \CoreLibs\Debug\FileWriter method tests
|
||||
*/
|
||||
final class CoreLibsDebugFileWriterTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function fsetFolderProvider(): array
|
||||
{
|
||||
return [
|
||||
'valid log folder name' => [
|
||||
0 => '/tmp/',
|
||||
1 => true,
|
||||
],
|
||||
'invalid log folder name' => [
|
||||
0 => 'some name',
|
||||
1 => false,
|
||||
],
|
||||
'not writeable log folder name' => [
|
||||
0 => '/opt',
|
||||
1 => false,
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function fsetFilenameProvider(): array
|
||||
{
|
||||
return [
|
||||
'valid log file name' => [
|
||||
0 => 'some_valid_name.log',
|
||||
1 => true,
|
||||
],
|
||||
'file name contains path' => [
|
||||
0 => 'log/debug.log',
|
||||
1 => false,
|
||||
],
|
||||
'invalid log file name' => [
|
||||
0 => 'invalid name',
|
||||
1 => false,
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function fdebugProvider(): array
|
||||
{
|
||||
return [
|
||||
'debug with default enter' => [
|
||||
0 => 'test string',
|
||||
1 => null,
|
||||
2 => true,
|
||||
3 => 'test string' . "\n"
|
||||
],
|
||||
'debug with no enter' => [
|
||||
0 => 'test string',
|
||||
1 => false,
|
||||
2 => true,
|
||||
3 => 'test string'
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @dataProvider fsetFolderProvider
|
||||
* @testdox fsetFolder $input will match $expected [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param boolean $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testFsetFolder(string $input, bool $expected): void
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\FileWriter::fsetFolder($input)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @dataProvider fsetFilenameProvider
|
||||
* @testdox fsetFilename $input will match $expected [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param boolean $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testFsetFilename(string $input, bool $expected): void
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\FileWriter::fsetFilename($input)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @dataProvider fdebugProvider
|
||||
* @testdox fdebug write $input with enter $enter and will be $expected and written $expected_log [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param boolean|null $enter
|
||||
* @param boolean $expected
|
||||
* @param string $expected_log
|
||||
* @return void
|
||||
*/
|
||||
public function testFdebug(string $input, ?bool $enter, bool $expected, string $expected_log): void
|
||||
{
|
||||
// set debug log folder
|
||||
$file = 'FileWriterTest.log';
|
||||
$folder = '/tmp';
|
||||
$debug_file = $folder . DIRECTORY_SEPARATOR . $file;
|
||||
$valid_folder = \CoreLibs\Debug\FileWriter::fsetFolder($folder);
|
||||
$this->assertTrue(
|
||||
$valid_folder
|
||||
);
|
||||
$valid_file = \CoreLibs\Debug\FileWriter::fsetFilename($file);
|
||||
$this->assertTrue(
|
||||
$valid_file
|
||||
);
|
||||
// write the log line
|
||||
if ($enter === null) {
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\FileWriter::fdebug($input)
|
||||
);
|
||||
} else {
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\FileWriter::fdebug($input, $enter)
|
||||
);
|
||||
}
|
||||
if (is_file($debug_file)) {
|
||||
// open file, load data, compre to expected_log
|
||||
$log_data = file_get_contents($debug_file);
|
||||
if ($log_data === false) {
|
||||
$this->fail('fdebug file not readable or not data: ' . $debug_file);
|
||||
}
|
||||
$this->assertStringEndsWith(
|
||||
$expected_log,
|
||||
$log_data
|
||||
);
|
||||
unlink($debug_file);
|
||||
} else {
|
||||
$this->fail('fdebug file not found: ' . $debug_file);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
1008
4dev/tests/Debug/CoreLibsDebugLoggingTest.php
Normal file
1008
4dev/tests/Debug/CoreLibsDebugLoggingTest.php
Normal file
File diff suppressed because it is too large
Load Diff
119
4dev/tests/Debug/CoreLibsDebugMemoryUsageTest.php
Normal file
119
4dev/tests/Debug/CoreLibsDebugMemoryUsageTest.php
Normal file
@@ -0,0 +1,119 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
use CoreLibs\Debug\MemoryUsage;
|
||||
|
||||
/**
|
||||
* Test class for Debug\MemoryUsage
|
||||
* @coversDefaultClass \CoreLibs\Debug\MemoryUsage
|
||||
* @testdox \CoreLibs\Debug\MemoryUsage method tests
|
||||
*/
|
||||
final class CoreLibsDebugMemoryUsageTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function memoryUsageProvider(): array
|
||||
{
|
||||
$regex_raw_off = '/^\[[\w\s_-]+\] Peak\/Curr\/Change: \d+(\.\d+)? ?\w{1,2}\/'
|
||||
. '\d+(\.\d+)? ?\w{1,2}\/'
|
||||
. 'Since Start: \d+(\.\d+)? ?\w{1,2} \| '
|
||||
. 'Since Last: \d+(\.\d+)? ?\w{1,2} \| '
|
||||
. 'Since Set: \d+(\.\d+)? ?\w{1,2}$/';
|
||||
$regex_raw_on = '/^\[[\w\s_-]+\] Peak\/Curr\/'
|
||||
// . 'Change: \d+(\.\d+)? ?\w{1,2}\/\d+(\.\d+)? ?\w{1,2} \[\d+\]\/'
|
||||
. 'Change: \d+(\.\d+)? ?\w{1,2}\/\d+(\.\d+)? ?\w{1,2}/'
|
||||
. 'Since Start: \d+(\.\d+)? ?\w{1,2} \[\d+\] \| '
|
||||
. 'Since Last: \d+(\.\d+)? ?\w{1,2} \[\d+\] \| '
|
||||
. 'Since Set: \d+(\.\d+)? ?\w{1,2} \[\d+\]$/';
|
||||
$regex_array = [
|
||||
'prefix' => '/^[\w\s_-]+$/',
|
||||
'peak' => '/^\d+$/',
|
||||
'usage' => '/^\d+$/',
|
||||
'start' => '/^\d+$/',
|
||||
'last' => '/^\d+$/',
|
||||
'set' => '/^\d+$/',
|
||||
];
|
||||
// 0: prefix
|
||||
// 1: raw flag
|
||||
// 2: set flags array
|
||||
// 3: array output expected (as regex)
|
||||
// 4: string output expected (as regex)
|
||||
return [
|
||||
'test normal' => [
|
||||
'test',
|
||||
null,
|
||||
[],
|
||||
$regex_array,
|
||||
$regex_raw_off,
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @cover ::resetMemory
|
||||
* @cover ::debugMemoryFlag
|
||||
* @cover ::setStartMemory
|
||||
* @cover ::setMemory
|
||||
* @cover ::memoryUsage
|
||||
* @cover ::printMemoryUsage
|
||||
* @dataProvider memoryUsageProvider
|
||||
* @testdox memoryUsage with $prefix, raw memory $raw [$_dataName]
|
||||
*
|
||||
* @param string $prefix
|
||||
* @param bool|null $raw
|
||||
* @param array $set_flags
|
||||
* @param array $expected_array
|
||||
* @param string $expected_string
|
||||
* @return void
|
||||
*/
|
||||
public function testMemoryUsage(
|
||||
string $prefix,
|
||||
?bool $raw,
|
||||
array $settings,
|
||||
array $expected_array,
|
||||
string $expected_string
|
||||
): void {
|
||||
// always reeset to null
|
||||
MemoryUsage::resetMemory();
|
||||
MemoryUsage::debugMemoryFlag(true);
|
||||
MemoryUsage::setStartMemory();
|
||||
MemoryUsage::setMemory();
|
||||
// run collector
|
||||
$memory = MemoryUsage::memoryUsage($prefix);
|
||||
if ($raw === null) {
|
||||
$string = MemoryUsage::printMemoryUsage($memory);
|
||||
} else {
|
||||
$string = MemoryUsage::printMemoryUsage($memory, $raw);
|
||||
}
|
||||
|
||||
// expected_array for each
|
||||
foreach ($expected_array as $name => $regex) {
|
||||
$this->assertMatchesRegularExpression(
|
||||
$regex,
|
||||
(string)$memory[$name],
|
||||
'assert memory usage array ' . $name
|
||||
);
|
||||
}
|
||||
|
||||
// regex match string
|
||||
$this->assertMatchesRegularExpression(
|
||||
$expected_string,
|
||||
$string,
|
||||
'assert memory usage string as regex'
|
||||
);
|
||||
|
||||
// TODO additional tests with use more memory and check diff matching
|
||||
// TODO reset memory usage test
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
183
4dev/tests/Debug/CoreLibsDebugRunningTimeTest.php
Normal file
183
4dev/tests/Debug/CoreLibsDebugRunningTimeTest.php
Normal file
@@ -0,0 +1,183 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* Test class for Debug\RunningTime
|
||||
* @coversDefaultClass \CoreLibs\Debug\RunningTime
|
||||
* @testdox \CoreLibs\Debug\RunningTime method tests
|
||||
*/
|
||||
final class CoreLibsDebugRunningTimeTest extends TestCase
|
||||
{
|
||||
public function hrRunningTimeProvider(): array
|
||||
{
|
||||
// 0: return time difference
|
||||
// 1: return time on first run in regex
|
||||
return [
|
||||
'default time' => [
|
||||
0 => null,
|
||||
1 => '/^\d{4}\.\d{1,}$/'
|
||||
],
|
||||
'nanoseconds' => [
|
||||
0 => 'ns',
|
||||
1 => '/^\d{10}$/'
|
||||
],
|
||||
'microseconds' => [
|
||||
0 => 'ys',
|
||||
1 => '/^\d{7}\.\d{1,}$/'
|
||||
],
|
||||
'milliseconds' => [
|
||||
0 => 'ms',
|
||||
1 => '/^\d{4}\.\d{1,}$/'
|
||||
],
|
||||
'seconds' => [
|
||||
0 => 's',
|
||||
1 => '/^\d{1}\.\d{4,}$/'
|
||||
],
|
||||
'invalid fallback to ms' => [
|
||||
0 => 'invalid',
|
||||
1 => '/^\d{4}\.\d{1,}$/'
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
public function runningTimeProvider(): array
|
||||
{
|
||||
return [
|
||||
'run time test' => [
|
||||
0 => '/^\d{1,}\.\d{1,}$/',
|
||||
1 => '/^Start: \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} 0\.\d{8}, $/',
|
||||
2 => '/^Start: \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} 0\.\d{8}, '
|
||||
. 'End: \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} 0\.\d{8}, '
|
||||
. 'Run: \d{1,}\.\d{1,} s$/'
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @cover ::hrRunningTime
|
||||
* @dataProvider hrRunningTimeProvider
|
||||
* @testdox hrRunningTime with $out_time matching $expected [$_dataName]
|
||||
*
|
||||
* @param string|null $out_time
|
||||
* @param string $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testHrRunningTime(?string $out_time, string $expected): void
|
||||
{
|
||||
// reset for each run
|
||||
\CoreLibs\Debug\RunningTime::hrRunningTimeReset();
|
||||
$start = \CoreLibs\Debug\RunningTime::hrRunningTime();
|
||||
$this->assertEquals(
|
||||
0,
|
||||
$start,
|
||||
'assert first run 0'
|
||||
);
|
||||
time_nanosleep(1, 500);
|
||||
if ($out_time === null) {
|
||||
$second = \CoreLibs\Debug\RunningTime::hrRunningTime();
|
||||
} else {
|
||||
$second = \CoreLibs\Debug\RunningTime::hrRunningTime($out_time);
|
||||
}
|
||||
// print "E: " . $end . "\n";
|
||||
$this->assertMatchesRegularExpression(
|
||||
$expected,
|
||||
(string)$second,
|
||||
'assert second run regex'
|
||||
);
|
||||
if ($out_time === null) {
|
||||
$end_second = \CoreLibs\Debug\RunningTime::hrRunningTimeFromStart();
|
||||
} else {
|
||||
$end_second = \CoreLibs\Debug\RunningTime::hrRunningTimeFromStart($out_time);
|
||||
}
|
||||
$this->assertEquals(
|
||||
$end_second,
|
||||
$second,
|
||||
'assert end is equal second'
|
||||
);
|
||||
// sleep again, second messurement
|
||||
time_nanosleep(1, 500);
|
||||
if ($out_time === null) {
|
||||
$third = \CoreLibs\Debug\RunningTime::hrRunningTime();
|
||||
} else {
|
||||
$third = \CoreLibs\Debug\RunningTime::hrRunningTime($out_time);
|
||||
}
|
||||
// third call is not null
|
||||
$this->assertNotEquals(
|
||||
0,
|
||||
$third,
|
||||
'assert third call not null'
|
||||
);
|
||||
// third call is bigger than end
|
||||
$this->assertNotEquals(
|
||||
$second,
|
||||
$third,
|
||||
'assert third different second'
|
||||
);
|
||||
// last messurement, must match start - end + last
|
||||
if ($out_time === null) {
|
||||
$end = \CoreLibs\Debug\RunningTime::hrRunningTimeFromStart();
|
||||
} else {
|
||||
$end = \CoreLibs\Debug\RunningTime::hrRunningTimeFromStart($out_time);
|
||||
}
|
||||
$this->assertGreaterThan(
|
||||
$third,
|
||||
$end,
|
||||
'assert end greater third'
|
||||
);
|
||||
// new start
|
||||
\CoreLibs\Debug\RunningTime::hrRunningTimeReset();
|
||||
$new_start = \CoreLibs\Debug\RunningTime::hrRunningTime();
|
||||
$this->assertEquals(
|
||||
0,
|
||||
$new_start,
|
||||
'assert new run 0'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @dataProvider runningTimeProvider
|
||||
* @testdox runningTime matching return $expected_number and start $expected_start end $expected_end [$_dataName]
|
||||
*
|
||||
* @param string $expected_number
|
||||
* @param string $expected_start
|
||||
* @param string $expected_end
|
||||
* @return void
|
||||
*/
|
||||
public function testRunningTime(string $expected_number, string $expected_start, string $expected_end): void
|
||||
{
|
||||
$start = \CoreLibs\Debug\RunningTime::runningTime(true);
|
||||
// print "Start: " . $start . "\n";
|
||||
$this->assertEquals(
|
||||
0,
|
||||
$start
|
||||
);
|
||||
// print "STRING: " . \CoreLibs\Debug\RunningTime::runningTimeString() . "\n";
|
||||
$this->assertMatchesRegularExpression(
|
||||
$expected_start,
|
||||
\CoreLibs\Debug\RunningTime::runningTimeString()
|
||||
);
|
||||
time_nanosleep(1, 500);
|
||||
$end = \CoreLibs\Debug\RunningTime::runningTime(true);
|
||||
// print "Start: " . $end . "\n";
|
||||
$this->assertMatchesRegularExpression(
|
||||
$expected_number,
|
||||
(string)$end
|
||||
);
|
||||
// print "STRING: " . \CoreLibs\Debug\RunningTime::runningTimeString() . "\n";
|
||||
$this->assertMatchesRegularExpression(
|
||||
$expected_end,
|
||||
\CoreLibs\Debug\RunningTime::runningTimeString()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
475
4dev/tests/Debug/CoreLibsDebugSupportTest.php
Normal file
475
4dev/tests/Debug/CoreLibsDebugSupportTest.php
Normal file
@@ -0,0 +1,475 @@
|
||||
<?php // phpcs:disable Generic.Files.LineLength
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* 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
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function printArrayProvider(): array
|
||||
{
|
||||
return [
|
||||
'empty array' => [
|
||||
0 => [],
|
||||
1 => "<pre>Array\n(\n)\n</pre>"
|
||||
],
|
||||
'simple array' => [
|
||||
0 => ['a', 'b'],
|
||||
1 => "<pre>Array\n(\n"
|
||||
. " [0] => a\n"
|
||||
. " [1] => b\n"
|
||||
. ")\n</pre>"
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function printBoolProvider(): array
|
||||
{
|
||||
return [
|
||||
'true input default' => [
|
||||
0 => true,
|
||||
1 => [],
|
||||
2 => 'true'
|
||||
],
|
||||
'false input default' => [
|
||||
0 => false,
|
||||
1 => [],
|
||||
2 => 'false'
|
||||
],
|
||||
'false input param name' => [
|
||||
0 => false,
|
||||
1 => [
|
||||
'name' => 'param test'
|
||||
],
|
||||
2 => '<b>param test</b>: false'
|
||||
],
|
||||
'true input param name, true override' => [
|
||||
0 => true,
|
||||
1 => [
|
||||
'name' => 'param test',
|
||||
'true' => 'ok'
|
||||
],
|
||||
2 => '<b>param test</b>: 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'
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* 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,
|
||||
"##HTMLPRE##"
|
||||
. "Array\n(\n"
|
||||
. " [0] => a\n"
|
||||
. " [1] => b\n"
|
||||
. ")\n"
|
||||
. "##/HTMLPRE##",
|
||||
],
|
||||
// resource
|
||||
'a resource' => [
|
||||
tmpfile(),
|
||||
null,
|
||||
'/^Resource id #\d+$/',
|
||||
],
|
||||
// object
|
||||
'an object' => [
|
||||
new \CoreLibs\Debug\Support(),
|
||||
null,
|
||||
'CoreLibs\Debug\Support',
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 ::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,
|
||||
\CoreLibs\Debug\Support::printTime()
|
||||
);
|
||||
} else {
|
||||
$this->assertMatchesRegularExpression(
|
||||
$regex,
|
||||
\CoreLibs\Debug\Support::printTime($microtime)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @cover ::printAr
|
||||
* @cover ::printArray
|
||||
* @dataProvider printArrayProvider
|
||||
* @testdox printAr/printArray $input will be $expected [$_dataName]
|
||||
*
|
||||
* @param array $input
|
||||
* @param string $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testPrintAr(array $input, string $expected): void
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\Support::printAr($input),
|
||||
'assert printAr'
|
||||
);
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\Support::printArray($input),
|
||||
'assert printArray'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @cover ::printBool
|
||||
* @dataProvider printBoolProvider
|
||||
* @testdox printBool $input will be $expected [$_dataName]
|
||||
*
|
||||
* @param bool $input
|
||||
* @param array $params
|
||||
* @param string $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testPrintBool(bool $input, array $params, string $expected): void
|
||||
{
|
||||
if (
|
||||
isset($params['name']) &&
|
||||
isset($params['true']) &&
|
||||
isset($params['false'])
|
||||
) {
|
||||
$string = \CoreLibs\Debug\Support::printBool(
|
||||
$input,
|
||||
$params['name'],
|
||||
$params['true'],
|
||||
$params['false']
|
||||
);
|
||||
} elseif (isset($params['name']) && isset($params['true'])) {
|
||||
$string = \CoreLibs\Debug\Support::printBool(
|
||||
$input,
|
||||
$params['name'],
|
||||
$params['true']
|
||||
);
|
||||
} elseif (isset($params['name'])) {
|
||||
$string = \CoreLibs\Debug\Support::printBool(
|
||||
$input,
|
||||
$params['name']
|
||||
);
|
||||
} else {
|
||||
$string = \CoreLibs\Debug\Support::printBool($input);
|
||||
}
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
$string,
|
||||
'assert printBool'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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,
|
||||
\CoreLibs\Debug\Support::printToString($input)
|
||||
);
|
||||
} else {
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\Support::printToString($input)
|
||||
);
|
||||
}
|
||||
} else {
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\Support::printToString($input, $flag)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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,
|
||||
\CoreLibs\Debug\Support::getCallerMethod()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @cover ::getCallerMethodList
|
||||
* @testWith [["main", "run", "run", "run", "run", "run", "run", "runBare", "runTest", "testGetCallerMethodList"],["include", "main", "run", "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, array $expected_group): void
|
||||
{
|
||||
$compare = \CoreLibs\Debug\Support::getCallerMethodList();
|
||||
// if we direct call we have 10, if we call as folder we get 11
|
||||
if (count($compare) == 10) {
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\Support::getCallerMethodList(),
|
||||
'assert expected 10'
|
||||
);
|
||||
} else {
|
||||
$this->assertEquals(
|
||||
$expected_group,
|
||||
\CoreLibs\Debug\Support::getCallerMethodList(),
|
||||
'assert expected group'
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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,
|
||||
\CoreLibs\Debug\Support::getCallerClass()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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,
|
||||
\CoreLibs\Debug\Support::debugString($input),
|
||||
'assert all default'
|
||||
);
|
||||
} elseif ($flag === null) {
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\Support::debugString($input, $replace),
|
||||
'assert flag default'
|
||||
);
|
||||
} else {
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Debug\Support::debugString($input, $replace, $flag),
|
||||
'assert all set'
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
3
4dev/tests/Debug/log/.gitignore
vendored
Normal file
3
4dev/tests/Debug/log/.gitignore
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
*log
|
||||
*LOG
|
||||
!.gitignore
|
||||
Reference in New Issue
Block a user