From 7fd50620649023266a8e02564bf0b9464007aaf5 Mon Sep 17 00:00:00 2001 From: Clemens Schwaighofer Date: Tue, 11 Jan 2022 19:58:33 +0900 Subject: [PATCH] Add PHP unit tests Check\* Combined\* Convert\* Create\Hash (stub) --- 4dev/tests/CoreLibsCheckEmailTest.php | 14 +- 4dev/tests/CoreLibsCheckFileTest.php | 92 ++- 4dev/tests/CoreLibsCheckPasswordTest.php | 69 ++ 4dev/tests/CoreLibsCheckPhpVersionTest.php | 62 ++ .../CoreLibsCombinedArrayHandlerTest.php | 773 ++++++++++++++++++ 4dev/tests/CoreLibsCombinedDateTimeTest.php | 596 ++++++++++++++ 4dev/tests/CoreLibsConvertByteTest.php | 219 +++++ 4dev/tests/CoreLibsConvertColorsTest.php | 380 +++++++++ 4dev/tests/CoreLibsConvertHtmlTest.php | 184 +++++ 4dev/tests/CoreLibsConvertJsonTest.php | 164 ++++ 4dev/tests/CoreLibsConvertMathTest.php | 8 +- 4dev/tests/CoreLibsConvertMimeAppNameTest.php | 57 ++ 4dev/tests/CoreLibsCreateHashTest.php | 64 ++ 4dev/tests/phpunit_flow_check.php | 58 ++ 14 files changed, 2697 insertions(+), 43 deletions(-) create mode 100644 4dev/tests/CoreLibsCheckPasswordTest.php create mode 100644 4dev/tests/CoreLibsCheckPhpVersionTest.php create mode 100644 4dev/tests/CoreLibsCombinedArrayHandlerTest.php create mode 100644 4dev/tests/CoreLibsCombinedDateTimeTest.php create mode 100644 4dev/tests/CoreLibsConvertByteTest.php create mode 100644 4dev/tests/CoreLibsConvertColorsTest.php create mode 100644 4dev/tests/CoreLibsConvertHtmlTest.php create mode 100644 4dev/tests/CoreLibsConvertJsonTest.php create mode 100644 4dev/tests/CoreLibsConvertMimeAppNameTest.php create mode 100644 4dev/tests/CoreLibsCreateHashTest.php create mode 100644 4dev/tests/phpunit_flow_check.php diff --git a/4dev/tests/CoreLibsCheckEmailTest.php b/4dev/tests/CoreLibsCheckEmailTest.php index f5054682..5778a0d6 100644 --- a/4dev/tests/CoreLibsCheckEmailTest.php +++ b/4dev/tests/CoreLibsCheckEmailTest.php @@ -41,7 +41,7 @@ final class CoreLibsCheckEmailTest extends TestCase * Test regex level return * * @dataProvider emailRegexProvider - * @testdox Email::getEmailRegex $input will be $expected [$_dataName] + * @testdox getEmailRegex $input will be $expected [$_dataName] * * @param int $input * @param string $expected @@ -94,7 +94,7 @@ final class CoreLibsCheckEmailTest extends TestCase * Undocumented function * * @dataProvider emailCheckProvider - * @testdox Email::checkEmail $input will be $expected [$_dataName] + * @testdox checkEmail $input will be $expected [$_dataName] * * @return void */ @@ -125,7 +125,7 @@ final class CoreLibsCheckEmailTest extends TestCase * Undocumented function * * @dataProvider emailCheckFullProvider - * @testdox Email::checkEmailFull $input will be $expected [$_dataName] + * @testdox checkEmailFull $input will be $expected [$_dataName] * * @param string $input * @param array $expected @@ -219,7 +219,7 @@ final class CoreLibsCheckEmailTest extends TestCase * Undocumented function * * @dataProvider emailRegexErrorProvider - * @testdox Email::getEmailRegexErrorMessage $input will be $expected [$_dataName] + * @testdox getEmailRegexErrorMessage $input will be $expected [$_dataName] * * @param integer $input * @param array $expected @@ -283,7 +283,7 @@ final class CoreLibsCheckEmailTest extends TestCase * Undocumented function * * @dataProvider emailTypeProviderLong - * @testdox Email::getEmailType $input will be normal $expected [$_dataName] + * @testdox getEmailType $input will be normal $expected [$_dataName] * * @param string $input * @param string $expected @@ -301,7 +301,7 @@ final class CoreLibsCheckEmailTest extends TestCase * Undocumented function * * @dataProvider emailTypeProviderShort - * @testdox Email::getEmailType $input will be short $expected [$_dataName] + * @testdox getEmailType $input will be short $expected [$_dataName] * * @param string $input * @param string $expected @@ -355,7 +355,7 @@ final class CoreLibsCheckEmailTest extends TestCase * Undocumented function * * @dataProvider emailProviderTypeLongToShort - * @testdox Email::getShortEmailType $input will be $expected [$_dataName] + * @testdox getShortEmailType $input will be $expected [$_dataName] * * @param string $input * @param string|bool $expected diff --git a/4dev/tests/CoreLibsCheckFileTest.php b/4dev/tests/CoreLibsCheckFileTest.php index 57e618c0..91912548 100644 --- a/4dev/tests/CoreLibsCheckFileTest.php +++ b/4dev/tests/CoreLibsCheckFileTest.php @@ -7,40 +7,42 @@ namespace tests; use PHPUnit\Framework\TestCase; /** - * Undocumented class + * Test class for Check\File * @testdox CoreLibs\Check\File method tests */ final class CoreLibsCheckFileTest extends TestCase { /** @var array */ - private $files = []; - - protected function setUp(): void - { - // write a dummy files for testing - } - - protected function tearDown(): void - { - // unlink files - } + // private $files_list = []; + /** @var string */ + private $base_folder = DIRECTORY_SEPARATOR . 'tmp' . DIRECTORY_SEPARATOR; /** * main file list + data provider * + * filename, file extension matching, lines in file, -1 for nothing + * * @return array */ public function filesList(): array { return [ - ['filename.txt', 'txt', 5] + ['filename.txt', 'txt', 5], + ['filename.csv', 'csv', 15], + ['filename.tsv', 'tsv', 0], + ['file_does_not_exits', '', -1], ]; } + /** + * Undocumented function + * + * @return array + */ public function filesExtensionProvider(): array { $list = []; - foreach ($this->filesList as $row) { + foreach ($this->filesList() as $row) { $list[$row[0] . ' must be extension ' . $row[1]] = [$row[0], $row[1]]; } return $list; @@ -49,40 +51,66 @@ final class CoreLibsCheckFileTest extends TestCase /** * Undocumented function * - * @#dataProvider filesExtensionProvider - * @#testdox File::getFilenameEnding Input $input must be $expected - * //string $input, string $expected + * @return array + */ + public function filesLinesProvider(): array + { + $list = []; + foreach ($this->filesList() as $row) { + $list[$row[0] . ' must have ' . $row[2] . ' lines'] = [$row[0], $row[2]]; + } + return $list; + } + + /** + * Tests if file extension matches * - * @param string $input - * @param string $expected + * @dataProvider filesExtensionProvider + * @testdox getFilenameEnding $input must be extension $expected [$_dataName] + * + * @param string $input + * @param string $expected * @return void */ - public function testGetFilenameEnding(): void + public function testGetFilenameEnding(string $input, string $expected): void { // getFilenameEnding - /* $this->assertEquals( + $this->assertEquals( $expected, \CoreLibs\Check\File::getFilenameEnding($input) - ); */ - $this->assertTrue(true, 'This should already work.'); - $this->markTestIncomplete( - 'testGetFilenameEnding has not been implemented yet.' ); } /** - * Undocumented function - * // string $input, string $expected + * Tests the file line read * + * @dataProvider filesLinesProvider + * @testdox getLinesFromFile $input must have $expected lines [$_dataName] + * + * @param string $input file name + * @param int $expected lines in file * @return void */ - public function testGetLinesFromFile(): void + public function testGetLinesFromFile(string $input, int $expected): void { - // getLinesFromFile - $this->assertTrue(true, 'This should already work.'); - $this->markTestIncomplete( - 'testGetLinesFromFile has not been implemented yet.' + // create file + if ($expected > -1) { + $file = $this->base_folder . $input; + $fp = fopen($file, 'w'); + for ($i = 0; $i < $expected; $i++) { + fwrite($fp, 'This is row ' . ($i + 1) . PHP_EOL); + } + fclose($fp); + } + // test + $this->assertEquals( + $expected, + \CoreLibs\Check\File::getLinesFromFile($this->base_folder . $input) ); + // unlink file + if (is_file($this->base_folder . $input)) { + unlink($this->base_folder . $input); + } } } diff --git a/4dev/tests/CoreLibsCheckPasswordTest.php b/4dev/tests/CoreLibsCheckPasswordTest.php new file mode 100644 index 00000000..b1d67ea8 --- /dev/null +++ b/4dev/tests/CoreLibsCheckPasswordTest.php @@ -0,0 +1,69 @@ + ['test', 'test', true], + 'not matching password' => ['test', 'not_test', false], + ]; + } + + public function passwordRehashProvider(): array + { + return [ + 'no rehash needed' => ['$2y$10$EgWJ2WE73DWi.hIyFRCdpejLXTvHbmTK3LEOclO1tAvXAXUNuUS4W', false], + 'rehash needed' => ['9c42a1346e333a770904b2a2b37fa7d3', true], + ]; + } + + /** + * Undocumented function + * + * @dataProvider passwordProvider + * @testdox passwordVerify $input compare to $input_hash: $expected [$_dataName] + * + * @param string $input + * @param string $input_hash + * @param boolean $expected + * @return void + */ + public function testPasswordSetVerify(string $input, string $input_hash, bool $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Check\Password::passwordVerify($input, \CoreLibs\Check\Password::passwordSet($input_hash)) + ); + } + + /** + * Undocumented function + * + * @dataProvider passwordRehashProvider + * @testdox passwordRehashCheck $input will be $expected [$_dataName] + * + * @param string $input + * @param boolean $expected + * @return void + */ + public function testPasswordRehashCheck(string $input, bool $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Check\Password::passwordRehashCheck($input) + ); + } +} + +// __END__ diff --git a/4dev/tests/CoreLibsCheckPhpVersionTest.php b/4dev/tests/CoreLibsCheckPhpVersionTest.php new file mode 100644 index 00000000..8c503630 --- /dev/null +++ b/4dev/tests/CoreLibsCheckPhpVersionTest.php @@ -0,0 +1,62 @@ + ['7', '', true], + 'min 7.4' => ['7.4', '', true], + 'min 7.4.1' => ['7.4.1', '', true], + // NOTE: update if php version bigger than 10 + 'min 10' => ['10', '', false], + 'min 10.0' => ['10.0', '', false], + 'min 10.0.0' => ['10.0.0', '', false], + // max version, NOTE: update if php version bigger than 10 + 'max 10' => ['7', '10', true], + 'max 10.0' => ['7', '10.0', true], + 'max 10.0.0' => ['7', '10.0.0', true], + // max version + 'max 7' => ['5', '7', false], + 'max 7.4' => ['5', '7.4', false], + 'max 7.4.1' => ['5', '7.4.1', false], + ]; + } + + /** + * Undocumented function + * + * @dataProvider phpVersionProvider + * @testdox checkPHPVersion $input_min and $input_max will be $expected [$_dataName] + * + * @param string $input_min + * @param string $input_max + * @param string $expected + * @return void + */ + public function testCheckPHPVersion(string $input_min, string $input_max, bool $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Check\PhpVersion::checkPHPVersion($input_min, $input_max) + ); + } +} + +// __END__ diff --git a/4dev/tests/CoreLibsCombinedArrayHandlerTest.php b/4dev/tests/CoreLibsCombinedArrayHandlerTest.php new file mode 100644 index 00000000..e7674b81 --- /dev/null +++ b/4dev/tests/CoreLibsCombinedArrayHandlerTest.php @@ -0,0 +1,773 @@ + [ + 'b' => 'bar', + 'c' => 'foo', + 'same' => 'same', + 3 => 'foobar', + 'foobar' => 4, + 'true' => true, + ], + 'd', + 4, + 'b', + 'c' => 'test', + 'same' => 'same', + 'deep' => [ + 'sub' => [ + 'nested' => 'bar', + 'same' => 'same', + 'more' => 'test' + ] + ] + ]; + + /** + * Undocumented function + * + * @return array + */ + public function arraySearchRecursiveProvider(): array + { + return [ + 'find value' => [ + 0 => 'bar', + 1 => self::$array, + 2 => null, + 3 => ['a', 'b'], + ], + 'find value with key' => [ + 0 => 'bar', + 1 => self::$array, + 2 => 'nested', + 3 => ['deep', 'sub', 'nested'] + ], + 'not existing value' => [ + 0 => 'not exists', + 1 => self::$array, + 2 => null, + 3 => [], + ], + 'find value int' => [ + 0 => 4, + 1 => self::$array, + 2 => null, + 3 => ['a', 'foobar'] + ], + 'find value int as string' => [ + 0 => '4', + 1 => self::$array, + 2 => null, + 3 => [] + ], + 'find value int as string with key' => [ + 0 => '4', + 1 => self::$array, + 2 => 'foobar', + 3 => [] + ], + 'first level value' => [ + 0 => 'd', + 1 => self::$array, + 2 => null, + 4 => [0] + ], + 'find value, return int key' => [ + 0 => 'foobar', + 1 => self::$array, + 2 => null, + 3 => ['a', 3] + ] + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function arraySearchRecursiveAllProvider(): array + { + return [ + 'find value' => [ + 0 => 'bar', + 1 => self::$array, + 2 => null, + 3 => true, + 4 => [ + 'level' => -1, + 'work' => [], + 'found' => [ + 0 => ['a', 'b'], + 1 => ['deep', 'sub', 'nested'] + ] + ] + ], + 'find value, new type' => [ + 0 => 'bar', + 1 => self::$array, + 2 => null, + 3 => false, + 4 => [ + 0 => ['a', 'b'], + 1 => ['deep', 'sub', 'nested'] + ] + ], + 'find value with key' => [ + 0 => 'bar', + 1 => self::$array, + 2 => 'nested', + 3 => true, + 4 => [ + 'level' => -1, + 'work' => [], + 'found' => [ + 0 => ['deep', 'sub', 'nested'] + ] + ] + ], + 'not existing value' => [ + 0 => 'not exists', + 1 => self::$array, + 2 => null, + 3 => true, + 4 => [ + 'level' => -1, + 'work' => [], + ], + ], + 'not existing value, new type' => [ + 0 => 'not exists', + 1 => self::$array, + 2 => null, + 3 => false, + 4 => [], + ], + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function arraySearchSimpleProvider(): array + { + return [ + 'key/value exist' => [ + 0 => self::$array, + 1 => 'c', + 2 => 'foo', + 3 => false, + 4 => true, + ], + 'key/value exists twice' => [ + 0 => self::$array, + 1 => 'same', + 2 => 'same', + 3 => false, + 4 => true, + ], + 'key/value not found' => [ + 0 => self::$array, + 1 => 'not exists', + 2 => 'not exists', + 3 => false, + 4 => false, + ], + 'key exists, value not' => [ + 0 => self::$array, + 1 => 'b', + 2 => 'not exists', + 3 => false, + 4 => false, + ], + 'key not, value exists' => [ + 0 => self::$array, + 1 => 'not exists', + 2 => 'bar', + 3 => false, + 4 => false, + ], + 'numeric key, value exists' => [ + 0 => self::$array, + 1 => 0, + 2 => 'd', + 3 => false, + 4 => true, + ], + 'numeric key as string, value exists' => [ + 0 => self::$array, + 1 => '0', + 2 => 'd', + 3 => false, + 4 => true, + ], + 'numeric key as string, value exists, strinct' => [ + 0 => self::$array, + 1 => '0', + 2 => 'd', + 3 => true, + 4 => false, + ], + 'key exists, value numeric' => [ + 0 => self::$array, + 1 => 'foobar', + 2 => 4, + 3 => false, + 4 => true, + ], + 'key exists, value numeric as string' => [ + 0 => self::$array, + 1 => 'foobar', + 2 => '4', + 3 => false, + 4 => true, + ], + 'key exists, value numeric as string, strict' => [ + 0 => self::$array, + 1 => 'foobar', + 2 => '4', + 3 => true, + 4 => false, + ], + 'key exists, value bool' => [ + 0 => self::$array, + 1 => 'true', + 2 => true, + 3 => false, + 4 => true, + ], + 'key exists, value bool as string' => [ + 0 => self::$array, + 1 => 'true', + 2 => 'true', + 3 => false, + 4 => true, + ], + 'key exists, value bool as string, strict' => [ + 0 => self::$array, + 1 => 'true', + 2 => 'true', + 3 => true, + 4 => false, + ], + ]; + } + + /** + * TODO: create provider for n array merge + * provides array listing for the merge test + * + * @return array + */ + public function arrayMergeRecursiveProvider(): array + { + return [ + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function arrayCompareProvider(): array + { + return [ + 'one matching' => [ + ['a', 'b', 'c'], + ['c', 'd', 'e'], + ['a', 'b', 'd', 'e'] + ], + 'all the same' => [ + ['a', 'b', 'c'], + ['a', 'b', 'c'], + [] + ], + 'all different' => [ + ['a', 'b'], + ['c', 'd'], + ['a', 'b', 'c', 'd'] + ], + 'empty arrays' => [ + [], + [], + [] + ] + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function inArrayAnyProvider(): array + { + return [ + 'all exist in haystack' => [ + [1], + [1, 2, 3, 4], + [1] + ], + 'not all exist in haystack' => [ + [1, 5], + [1, 2, 3, 4], + [1] + ], + 'none exist in haystack' => [ + [5], + [1, 2, 3, 4], + false + ], + ]; + } + + public function genAssocArrayProvider(): array + { + return [ + 'non set' => [ + [ + 0 => ['a' => 'a1', 'b' => 2], + 1 => ['a' => 'a2', 'b' => 3], + 2 => ['a' => '', 'b' => null], + ], + false, + false, + false, + [], + ], + 'key set' => [ + [ + 0 => ['a' => 'a1', 'b' => 2], + 1 => ['a' => 'a2', 'b' => 3], + 2 => ['a' => '', 'b' => null], + ], + 'a', + false, + false, + ['a1' => 0, 'a2' => 1], + ], + 'value set' => [ + [ + 0 => ['a' => 'a1', 'b' => 2], + 1 => ['a' => 'a2', 'b' => 3], + 2 => ['a' => '', 'b' => null], + ], + false, + 'a', + false, + [0 => 'a1', 1 => 'a2', 2 => ''], + ], + 'key and value set, add empty, null' => [ + [ + 0 => ['a' => 'a1', 'b' => 2], + 1 => ['a' => 'a2', 'b' => 3], + 2 => ['a' => '', 'b' => null], + ], + 'a', + 'b', + false, + ['a1' => 2, 'a2' => 3], + ], + 'key and value set, add empty' => [ + [ + 0 => ['a' => 'a1', 'b' => 2], + 1 => ['a' => 'a2', 'b' => 3], + 2 => ['a' => '', 'b' => ''], + 3 => ['a' => 'a4', 'b' => ''], + ], + 'a', + 'b', + false, + ['a1' => 2, 'a2' => 3, 'a4' => ''], + ], + 'key/value set, skip empty' => [ + [ + 0 => ['a' => 'a1', 'b' => 2], + 1 => ['a' => 'a2', 'b' => 3], + 2 => ['a' => '', 'b' => null], + ], + 'a', + 'b', + true, + ['a1' => 2, 'a2' => 3], + ], + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function flattenArrayProvider(): array + { + return [ + 'array key/value, single' => [ + 0 => ['a' => 'foo', 1 => 'bar', 'c' => 2], + 1 => ['foo', 'bar', 2], + 2 => ['a', 1, 'c'], + 3 => ['a', 1, 'c'], + ], + 'array values, single' => [ + 0 => ['foo', 'bar', 2], + 1 => ['foo', 'bar', 2], + 2 => [0, 1, 2], + 3 => [0, 1, 2], + ], + 'array key/value, multi' => [ + 0 => [ + 'a' => ['a1' => 'a1foo', 'a2' => 'a1bar'], + 1 => 'bar', + 'c' => [2, 3, 4], + 'd' => [ + 'e' => [ + 'de1' => 'subfoo', 'de2' => 'subbar', 'a2' => 'a1bar' + ] + ] + ], + 1 => ['a1foo', 'a1bar', 'bar', 2, 3, 4, 'subfoo', 'subbar', 'a1bar'], + 2 => ['a', 'a1', 'a2', 1, 'c', 0, 1, 2, 'd', 'e', 'de1', 'de2', 'a2'], + 3 => ['a1', 'a2', 1, 0, 1, 2, 'de1', 'de2', 'a2'], + ], + 'array with double values' => [ + 0 => ['a', 'a', 'b'], + 1 => ['a', 'a', 'b'], + 2 => [0, 1, 2], + 3 => [0, 1, 2], + ] + ]; + } + + /** + * use the flattenArrayProvider and replace 1 with 2 array pos + * + * @return array + */ + public function flattenArrayKeyProvider(): array + { + $list = []; + foreach ($this->flattenArrayProvider() as $key => $row) { + $list[$key] = [ + $row[0], + $row[2], + ]; + } + return $list; + } + + /** + * use the flattenArrayProvider and replace 1 with ３ array pos + * + * @return array + */ + public function flattenArrayKeyLeavesOnlyProvider(): array + { + $list = []; + foreach ($this->flattenArrayProvider() as $key => $row) { + $list[$key] = [ + $row[0], + $row[3], + ]; + } + return $list; + } + + /** + * Undocumented function + * + * @return array + */ + public function arrayFlatForKeyProvider(): array + { + return [ + 'all present, single level' => [ + 0 => [ + 'a' => ['b1' => 'foo', 'a2' => 'a-foo'], + 'b' => ['b1' => 'bar', 'a2' => 'b-foo'], + 'c' => ['b1' => 'foobar', 'a2' => 'c-foo'], + ], + 1 => 'a2', + 2 => [ + 'a' => 'a-foo', + 'b' => 'b-foo', + 'c' => 'c-foo', + ], + ], + 'no sub arrays' => [ + 0 => ['a', 'b', 'c'], + 1 => 'a', + 2 => ['a', 'b', 'c'], + ], + 'sub arrays with missing' => [ + 0 => [ + 'a' => ['b1' => 'foo', 'a2' => 'a-foo'], + 'b' => ['b1' => 'bar'], + 'c' => ['b1' => 'foobar', 'a2' => 'c-foo'], + ], + 1 => 'a2', + 2 => [ + 'a' => 'a-foo', + 'b' => ['b1' => 'bar'], + 'c' => 'c-foo', + ], + ], + 'deep nested sub arrays' => [ + 0 => [ + 'a' => [ + 'b1' => 'foo', + 'a2' => [ + 'text' => ['a-foo', 'a-bar'], + ], + ], + 'b' => [ + 'b1' => 'bar', + 'a2' => [ + 'text' => 'b-foo', + ], + ], + ], + 1 => 'a2', + 2 => [ + 'a' => [ + 'text' => ['a-foo', 'a-bar'], + ], + 'b' => [ + 'text' => 'b-foo', + ], + ], + ] + ]; + } + + /** + * Undocumented function + * + * @dataProvider arraySearchRecursiveProvider + * @testdox arraySearchRecursive $needle (key $key_search_for) in $input and will be $expected [$_dataName] + * + * @param string|null $needle + * @param array $input + * @param string|null $key_search_for + * @return void + */ + public function testArraySearchRecursive($needle, array $input, ?string $key_search_for, array $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::arraySearchRecursive($needle, $input, $key_search_for) + ); + } + + /** + * Undocumented function + * + * @dataProvider arraySearchRecursiveAllProvider + * @testdox arraySearchRecursiveAll $needle (key $key_search_for) in $input and will be $expected (old: $flag) [$_dataName] + * + * @param string|null $needle + * @param array $input + * @param string|null $key_search_for + * @param bool $flag + * @return void + */ + public function testArraySearchRecursiveAll($needle, array $input, ?string $key_search_for, bool $flag, array $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::arraySearchRecursiveAll($needle, $input, $key_search_for, $flag) + ); + } + + /** + * Undocumented function + * + * @dataProvider arraySearchSimpleProvider + * @testdox arraySearchSimple $input searched with key: $key / value: $value (strict: $flag) will be $expected [$_dataName] + * + * @param array $input + * @param string|int $key + * @param string|int $value + * @param bool $expected + * @return void + */ + public function testArraySearchSimple(array $input, $key, $value, bool $flag, bool $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::arraySearchSimple($input, $key, $value, $flag) + ); + } + + /** + * Undocumented function + * + * @#dataProvider arrayMergeRecursiveProvider + * @testdox arrayMergeRecursive ... will be $expected [$_dataName] + * + * @param array $input nested array set as each parameter + * @param bool $flag + * @param bool|array $expected + * @return void + * array $input, bool $flag, $expected + */ + public function testArrayMergeRecursive(): void + { + $this->assertTrue(true, 'Implement proper test run'); + $this->markTestIncomplete( + 'testArrayMergeRecursive has not been implemented yet.' + ); + } + + /** + * Undocumented function + * + * @dataProvider arrayCompareProvider + * @testdox arrayDiff $input_a diff $input_b will be $expected [$_dataName] + * + * @param array $input_a + * @param array $input_b + * @param array $expected + * @return void + */ + public function testArrayDiff(array $input_a, array $input_b, array $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::arrayDiff($input_a, $input_b) + ); + } + + /** + * Undocumented function + * + * @dataProvider inArrayAnyProvider + * @testdox inArrayAny needle $input_a in haystack $input_b will be $expected [$_dataName] + * + * @param array $input_a + * @param array $input_b + * @param array|bool $expected + * @return void + */ + public function testInArrayAny(array $input_a, array $input_b, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::inArrayAny($input_a, $input_b) + ); + } + + /** + * Undocumented function + * + * @dataProvider genAssocArrayProvider + * @testdox genAssocArray array $input with $key or $value and flag set only $flag will be $expected [$_dataName] + * + * @param array $input + * @param string|int|bool $key + * @param string|int|bool $value + * @param bool $flag + * @param array $expected + * @return void + */ + public function testGenAssocArray(array $input, $key, $value, bool $flag, array $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::genAssocArray($input, $key, $value, $flag) + ); + } + + /** + * Undocumented function + * + * @dataProvider flattenArrayProvider + * @testdox testFlattenArray array $input will be $expected [$_dataName] + * + * @param array $input + * @param array $expected + * @return void + */ + public function testFlattenyArray(array $input, array $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::flattenArray($input) + ); + } + + /** + * Undocumented function + * + * @dataProvider flattenArrayKeyProvider + * @testdox flattenArrayKey array $input will be $expected [$_dataName] + * + * @param array $input + * @param array $expected + * @return void + */ + public function testFlattenArrayKey(array $input, array $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::flattenArrayKey($input) + ); + } + + /** + * Undocumented function + * + * @dataProvider flattenArrayKeyLeavesOnlyProvider + * @testdox flattenArrayKeyLeavesOnly array $input will be $expected [$_dataName] + * + * @param array $input + * @param array $expected + * @return void + */ + public function testFlattenArrayKeyLeavesOnly(array $input, array $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::flattenArrayKeyLeavesOnly($input) + ); + } + + /** + * Undocumented function + * + * @dataProvider arrayFlatForKeyProvider + * @testdox arrayFlatForKey array $input will be $expected [$_dataName] + * + * @param array $input + * @param array $expected + * @return void + */ + public function testArrayFlatForKey(array $input, $search, array $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\ArrayHandler::arrayFlatForKey($input, $search) + ); + } +} + +// __END__ diff --git a/4dev/tests/CoreLibsCombinedDateTimeTest.php b/4dev/tests/CoreLibsCombinedDateTimeTest.php new file mode 100644 index 00000000..273bea33 --- /dev/null +++ b/4dev/tests/CoreLibsCombinedDateTimeTest.php @@ -0,0 +1,596 @@ + [ + 1641515890, + false, + '2022-01-07 09:38:10', + ], + 'valid timestamp with microtime' => [ + 1641515890, + true, + '2022-01-07 09:38:10', + ], + 'valid micro timestamp with microtime' => [ + 1641515890.123456, + true, + '2022-01-07 09:38:10 1235ms', + ], + 'valid micro timestamp no microtime' => [ + 1641515890.123456, + false, + '2022-01-07 09:38:10', + ], + 'invalid timestamp' => [ + -123123, + false, + '1969-12-30 22:47:57', + ], + ]; + } + + /** + * interval for both directions + * + * @return array + */ + public function intervalProvider(): array + { + return [ + 'interval no microtime' => [ + 1641515890, + false, + '18999d 0h 38m 10s', + ], + 'interval with microtime' => [ + 1641515890, + true, + '18999d 0h 38m 10s', + ], + 'micro interval no microtime' => [ + 1641515890.123456, + false, + '18999d 0h 38m 10s', + ], + 'micro interval with microtime' => [ + 1641515890.123456, + true, + '18999d 0h 38m 10s 1235ms', + ], + 'negative interval no microtime' => [ + -1641515890, + false, + '-18999d 0h 38m 10s', + ], + // short for mini tests + 'microtime only' => [ + 0.123456, + true, + '0s 1235ms', + ], + 'seconds only' => [ + 30.123456, + true, + '30s 1235ms', + ], + 'minutes only' => [ + 90.123456, + true, + '1m 30s 1235ms', + ], + 'hours only' => [ + 3690.123456, + true, + '1h 1m 30s 1235ms', + ], + 'days only' => [ + 90090.123456, + true, + '1d 1h 1m 30s 1235ms', + ], + 'already set' => [ + '1d 1h 1m 30s 1235ms', + true, + '1d 1h 1m 30s 1235ms', + ], + 'invalid data' => [ + 'xyz', + true, + '0s', + ], + 'out of bounds timestamp' => [ + 999999999999999, + false, + '1s' + ] + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function reverseIntervalProvider(): array + { + return [ + 'interval no microtime' => [ + '18999d 0h 38m 10s', + 1641515890, + ], + 'micro interval with microtime' => [ + '18999d 0h 38m 10s 1235ms', + 1641515890.1235, + ], + 'micro interval with microtime' => [ + '18999d 0h 38m 10s 1234567890ms', + 1641515890.1234567, + ], + 'negative interval no microtime' => [ + '-18999d 0h 38m 10s', + -1641515890, + ], + // short for mini tests + 'microtime only' => [ + '0s 1235ms', + 0.1235, + ], + 'seconds only' => [ + '30s 1235ms', + 30.1235, + ], + 'minutes only' => [ + '1m 30s 1235ms', + 90.1235, + ], + 'hours only' => [ + '1h 1m 30s 1235ms', + 3690.1235, + ], + 'days only' => [ + '1d 1h 1m 30s 1235ms', + 90090.1235, + ], + 'already set' => [ + 1641515890, + 1641515890, + ], + 'invalid data' => [ + 'xyz', + 'xyz', + ], + 'out of bound data' => [ + '99999999999999999999d', + 8.64E+24 + ], + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function dateProvider(): array + { + return [ + 'valid date with -' => [ + '2021-12-12', + true, + ], + 'valid date with /' => [ + '2021/12/12', + true, + ], + 'valid date time with -' => [ + '2021-12-12 12:12:12', + true, + ], + 'invalid date' => [ + '2021-31-31', + false, + ], + 'invalid date string' => [ + 'xyz', + false, + ], + 'out of bound date' => [ + '9999-12-31', + true + ] + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function dateTimeProvider(): array + { + return [ + 'valid date time with -' => [ + '2021-12-12 12:12:12', + true, + ], + 'valid date time with /' => [ + '2021/12/12 12:12:12', + true, + ], + 'vald date time with hour/min' => [ + '2021/12/12 12:12', + true, + ], + 'valid date missing time' => [ + '2021-12-12', + false, + ], + 'valid date invalid time string' => [ + '2021-12-12 ab:cd', + false, + ], + 'invalid hour +' => [ + '2021-12-12 35:12', + false, + ], + 'invalid hour -' => [ + '2021-12-12 -12:12', + false, + ], + 'invalid minute +' => [ + '2021-12-12 23:65:12', + false, + ], + 'invalid minute -' => [ + '2021-12-12 23:-12:12', + false, + ], + 'invalid seconds +' => [ + '2021-12-12 23:12:99', + false, + ], + 'invalid seconds -' => [ + '2021-12-12 23:12:-12', + false, + ], + 'invalid seconds string' => [ + '2021-12-12 23:12:ss', + false, + ], + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function dateCompareProvider(): array + { + return [ + 'first date smaller' => [ + '2020-12-12', + '2021-12-12', + -1, + ], + 'dates equal' => [ + '2020-12-12', + '2020-12-12', + 0, + ], + 'second date smaller' => [ + '2021-12-12', + '2020-12-12', + 1 + ], + 'dates equal with different time' => [ + '2020-12-12 12:12:12', + '2020-12-12 13:13:13', + 0, + ], + 'invalid dates --' => [ + '--', + '--', + false + ], + 'empty dates' => [ + '', + '', + false + ], + 'invalid dates' => [ + 'not a date', + 'not a date either', + false, + ], + 'out of bound dates' => [ + '1900-1-1', + '9999-12-31', + -1 + ] + ]; + } + + public function dateTimeCompareProvider(): array + { + return [ + 'first date smaller no time' => [ + '2020-12-12', + '2021-12-12', + -1, + ], + 'dates equal no timestamp' => [ + '2020-12-12', + '2020-12-12', + 0, + ], + 'second date smaller no timestamp' => [ + '2021-12-12', + '2020-12-12', + 1 + ], + 'date equal first time smaller' => [ + '2020-12-12 12:12:12', + '2020-12-12 13:13:13', + -1, + ], + 'date equal time equal' => [ + '2020-12-12 12:12:12', + '2020-12-12 12:12:12', + 0, + ], + 'date equal second time smaller' => [ + '2020-12-12 13:13:13', + '2020-12-12 12:12:12', + 1, + ], + 'valid date invalid time' => [ + '2020-12-12 13:99:13', + '2020-12-12 12:12:99', + false, + ], + 'invalid datetimes --' => [ + '--', + '--', + false, + ], + 'empty datetimess' => [ + '', + '', + false, + ], + 'invalid datetimes' => [ + 'not a date', + 'not a date either', + false, + ], + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function daysIntervalProvider(): array + { + return [ + 'valid interval /, not named array' => [ + '2020/1/1', + '2020/1/30', + false, + [29, 22, 8], + ], + 'valid interval /, named array' => [ + '2020/1/1', + '2020/1/30', + true, + ['overall' => 29, 'weekday' => 22, 'weekend' => 8], + ], + 'valid interval -' => [ + '2020-1-1', + '2020-1-30', + false, + [29, 22, 8], + ], + 'valid interval switched' => [ + '2020/1/30', + '2020/1/1', + false, + [28, 0, 0], + ], + 'valid interval with time' => [ + '2020/1/1 12:12:12', + '2020/1/30 13:13:13', + false, + [28, 21, 8], + ], + 'invalid dates' => [ + 'abc', + 'xyz', + false, + [0, 0, 0] + ], + // this test will take a long imte + 'out of bound dates' => [ + '1900-1-1', + '9999-12-31', + false, + [2958463,2113189,845274], + ], + ]; + } + + /** + * date string convert test + * + * @dataProvider timestampProvider + * @testdox dateStringFormat $input (microtime $flag) will be $expected [$_dataName] + * + * @param int|float $input + * @param bool $flag + * @param string $expected + * @return void + */ + public function testDateStringFormat($input, bool $flag, string $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\DateTime::dateStringFormat($input, $flag) + ); + } + + /** + * interval convert test + * + * @dataProvider intervalProvider + * @testdox timeStringFormat $input (microtime $flag) will be $expected [$_dataName] + * + * @param int|float $input + * @param bool $flag + * @param string $expected + * @return void + */ + public function testTimeStringFormat($input, bool $flag, string $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\DateTime::timeStringFormat($input, $flag) + ); + } + + /** + * Undocumented function + * + * @dataProvider reverseIntervalProvider + * @testdox stringToTime $input will be $expected [$_dataName] + * + * @param string|int|float $input + * @param string|int|float $expected + * @return void + */ + public function testStringToTime($input, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\DateTime::stringToTime($input) + ); + } + + /** + * Undocumented function + * + * @dataProvider dateProvider + * @testdox checkDate $input will be $expected [$_dataName] + * + * @param string $input + * @param bool $expected + * @return void + */ + public function testCheckDate(string $input, bool $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\DateTime::checkDate($input) + ); + } + + /** + * Undocumented function + * + * @dataProvider dateTimeProvider + * @testdox checkDateTime $input will be $expected [$_dataName] + * + * @param string $input + * @param bool $expected + * @return void + */ + public function testCheckDateTime(string $input, bool $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\DateTime::checkDateTime($input) + ); + } + + /** + * Undocumented function + * + * @dataProvider dateCompareProvider + * @testdox compareDate $input_a compared to $input_b will be $expected [$_dataName] + * + * @param string $input_a + * @param string $input_b + * @param int|bool $expected + * @return void + */ + public function testCompareDate(string $input_a, string $input_b, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\DateTime::compareDate($input_a, $input_b) + ); + } + + /** + * Undocumented function + * + * @dataProvider dateTimeCompareProvider + * @testdox compareDateTime $input_a compared to $input_b will be $expected [$_dataName] + * + * @param string $input_a + * @param string $input_b + * @param int|bool $expected + * @return void + */ + public function testCompareDateTime(string $input_a, string $input_b, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\DateTime::compareDateTime($input_a, $input_b) + ); + } + + /** + * Undocumented function + * + * @dataProvider daysIntervalProvider + * @testdox calcDaysInterval $input_a compared to $input_b will be $expected [$_dataName] + * @medium + * + * @param string $input_a + * @param string $input_b + * @param bool $flag + * @param array $expected + * @return void + */ + public function testCalcDaysInterval(string $input_a, string $input_b, bool $flag, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Combined\DateTime::calcDaysInterval($input_a, $input_b, $flag) + ); + } +} + +// __END__ diff --git a/4dev/tests/CoreLibsConvertByteTest.php b/4dev/tests/CoreLibsConvertByteTest.php new file mode 100644 index 00000000..db90541b --- /dev/null +++ b/4dev/tests/CoreLibsConvertByteTest.php @@ -0,0 +1,219 @@ + [ + 0 => -123123123, + 1 => '-117.42 MB', + 2 => '-123.12 MiB', + 3 => '-117.42MB', + 4 => '-117.42 MB', + 5 => '-123.12MiB', + ], + 'kilobyte minus one' => [ + 0 => 999999, // KB-1 + 1 => '976.56 KB', + 2 => '1 MiB', + 3 => '976.56KB', + 4 => '976.56 KB', + 5 => '1MiB', + ], + 'megabyte minus one' => [ + 0 => 999999999, // MB-1 + 1 => '953.67 MB', + 2 => '1 GiB', + 3 => '953.67MB', + 4 => '953.67 MB', + 5 => '1GiB', + ], + 'megabyte' => [ + 0 => 254779258, + 1 => '242.98 MB', + 2 => '254.78 MiB', + 3 => '242.98MB', + 4 => '242.98 MB', + 5 => '254.78MiB', + ], + 'terabyte minus one' => [ + 0 => 999999999999999, // TB-1 + 1 => '909.49 TB', + 2 => '1 PiB', + 3 => '909.49TB', + 4 => '909.49 TB', + 5 => '1PiB', + ], + 'terabyte' => [ + 0 => 588795544887632, // TB-n + 1 => '535.51 TB', + 2 => '588.8 TiB', + 3 => '535.51TB', + 4 => '535.51 TB', + 5 => '588.8TiB', + ], + 'petabyte minus one' => [ + 0 => 999999999999999999, // PB-1 + 1 => '888.18 PB', + 2 => '1 EiB', + 3 => '888.18PB', + 4 => '888.18 PB', + 5 => '1EiB', + ], + 'max int value' => [ + 0 => 9223372036854775807, // MAX INT + 1 => '8 EB', + 2 => '9.22 EiB', + 3 => '8EB', + 4 => '8.00 EB', + 5 => '9.22EiB', + ], + 'exabyte minus 1' => [ + 0 => 999999999999999999999, // EB-1 + 1 => '867.36 EB', + 2 => '1000 EiB', + 3 => '867.36EB', + 4 => '867.36 EB', + 5 => '1000EiB', + ], + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function byteStringProvider(): array + { + return [ + 'negative number' => [ + 0 => '-117.42 MB', + 1 => -123123794, + 2 => -117420000, + ], + 'megabyte' => [ + 0 => '242.98 MB', + 1 => 254782996, + 2 => 242980000 + ], + 'megabyte si' => [ + 0 => '254.78 MiB', + 1 => 267156193, + 2 => 254780000 + ], + 'petabyte' => [ + 0 => '1 EiB', + 1 => 1152921504606846976, + 2 => 1000000000000000000, + ], + 'max int' => [ + 0 => '8 EB', + 1 => -9223372036854775807 - 1, + 2 => 8000000000000000000, + ], + 'exabyte, overflow' => [ + 0 => '867.36EB', + 1 => 3873816255479021568, + 2 => 363028535651074048, + ] + ]; + } + + /** + * Undocumented function + * + * @dataProvider byteProvider + * @testdox humanReadableByteFormat $input will be $expected, $expected_si SI, $expected_no_space no space, $expected_adjust adjust, $expected_si_no_space SI/no space [$_dataName] + * + * @param string|int|float $input + * @param string $expected + * @param string $expected_si + * @param string $expected_no_space + * @param string $expected_adjust + * @param string $expected_si_no_space + * @return void + */ + public function testHumanReadableByteFormat( + $input, + string $expected, + string $expected_si, + string $expected_no_space, + string $expected_adjust, + string $expected_si_no_space + ): void { + // 1024 + $this->assertEquals( + $expected, + \CoreLibs\Convert\Byte::humanReadableByteFormat($input) + ); + // 1000 + $this->assertEquals( + $expected_si, + \CoreLibs\Convert\Byte::humanReadableByteFormat($input, \CoreLibs\Convert\Byte::BYTE_FORMAT_SI) + ); + // no space + $this->assertEquals( + $expected_no_space, + \CoreLibs\Convert\Byte::humanReadableByteFormat($input, \CoreLibs\Convert\Byte::BYTE_FORMAT_NOSPACE) + ); + // always 2 decimals + $this->assertEquals( + $expected_adjust, + \CoreLibs\Convert\Byte::humanReadableByteFormat($input, \CoreLibs\Convert\Byte::BYTE_FORMAT_ADJUST) + ); + // combined si + no space + $this->assertEquals( + $expected_si_no_space, + \CoreLibs\Convert\Byte::humanReadableByteFormat( + $input, + \CoreLibs\Convert\Byte::BYTE_FORMAT_SI | \CoreLibs\Convert\Byte::BYTE_FORMAT_NOSPACE + ) + ); + } + + /** + * Undocumented function + * + * @dataProvider byteStringProvider + * @testdox stringByteFormat $input will be $expected and $expected_si SI [$_dataName] + * + * @param string|int|float $input + * @param string|int|float $expected + * @param string|int|float $expected_si + * @return void + */ + public function testStringByteFormat($input, $expected, $expected_si): void + { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Byte::stringByteFormat($input) + ); + $this->assertEquals( + $expected_si, + \CoreLibs\Convert\Byte::stringByteFormat($input, \CoreLibs\Convert\Byte::BYTE_FORMAT_SI) + ); + } +} + +// __END__ diff --git a/4dev/tests/CoreLibsConvertColorsTest.php b/4dev/tests/CoreLibsConvertColorsTest.php new file mode 100644 index 00000000..6414c090 --- /dev/null +++ b/4dev/tests/CoreLibsConvertColorsTest.php @@ -0,0 +1,380 @@ + [ + 0 => 10, + 1 => 100, + 2 => 200, + 3 => '#0a64c8', + 4 => '0a64c8' + ], + 'gray' => [ + 0 => 12, + 1 => 12, + 2 => 12, + 3 => '#0c0c0c', + 4 => '0c0c0c', + ], + 'black' => [ + 0 => 0, + 1 => 0, + 2 => 0, + 3 => '#000000', + 4 => '000000', + ], + 'white' => [ + 0 => 255, + 1 => 255, + 2 => 255, + 3 => '#ffffff', + 4 => 'ffffff', + ], + 'invalid color red & green' => [ + 0 => -12, + 1 => 300, + 2 => 12, + 3 => false, + 4 => false + ], + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function hex2rgbColorProvider(): array + { + return [ + 'color' => [ + 0 => '#0a64c8', + 1 => ['r' => 10, 'g' => 100, 'b' => 200], + 2 => '10,100,200', + 3 => ';', + 4 => '10;100;200', + ], + 'gray, long' => [ + 0 => '0c0c0c', + 1 => ['r' => 12, 'g' => 12, 'b' => 12], + 2 => '12,12,12', + 3 => ';', + 4 => '12;12;12', + ], + 'gray, short' => [ + 0 => 'ccc', + 1 => ['r' => 204, 'g' => 204, 'b' => 204], + 2 => '204,204,204', + 3 => ';', + 4 => '204;204;204', + ], + 'hex string with #' => [ + 0 => '#0c0c0c', + 1 => ['r' => 12, 'g' => 12, 'b' => 12], + 2 => '12,12,12', + 3 => ';', + 4 => '12;12;12', + ], + 'a too long hex string' => [ + 0 => '#0c0c0c0c', + 1 => false, + 2 => false, + 3 => ';', + 4 => false, + ], + 'a too short hex string' => [ + 0 => '0c0c', + 1 => false, + 2 => false, + 3 => ';', + 4 => false, + ] + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function rgb2hslAndhsbList(): array + { + return [ + 'valid gray' => [ + 'rgb' => [12, 12, 12], + 'hsb' => [0, 0, 5], + 'hsb_rgb' => [13, 13, 13], // should be rgb, but rounding in this + 'hsl' => [0.0, 0.0, 4.7], + 'valid' => true, + ], + 'valid color' => [ + 'rgb' => [10, 100, 200], + 'hsb' => [212, 95, 78], + 'hsb_rgb' => [10, 98, 199], // should be rgb, but rounding error + 'hsl' => [211.6, 90.5, 41.2], + 'valid' => true, + ], + // invalid values + 'invalid color' => [ + 'rgb' => [-12, 300, 12], + 'hsb' => [-12, 300, 12], + 'hsl' => [-12, 300, 12], + 'valid' => false, + ], + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function rgb2hsbColorProvider(): array + { + $list = []; + foreach ($this->rgb2hslAndhsbList() as $name => $values) { + $list[$name . ', rgb to hsb'] = [ + 0 => $values['rgb'][0], + 1 => $values['rgb'][1], + 2 => $values['rgb'][2], + 3 => $values['valid'] ? $values['hsb'] : false + ]; + } + return $list; + } + + /** + * Undocumented function + * + * @return array + */ + public function hsb2rgbColorProvider(): array + { + $list = []; + foreach ($this->rgb2hslAndhsbList() as $name => $values) { + $list[$name . ', hsb to rgb'] = [ + 0 => $values['hsb'][0], + 1 => $values['hsb'][1], + 2 => $values['hsb'][2], + 3 => $values['valid'] ? $values['hsb_rgb'] : false + ]; + } + return $list; + } + + /** + * Undocumented function + * + * @return array + */ + public function rgb2hslColorProvider(): array + { + $list = []; + foreach ($this->rgb2hslAndhsbList() as $name => $values) { + $list[$name . ', rgb to hsl'] = [ + 0 => $values['rgb'][0], + 1 => $values['rgb'][1], + 2 => $values['rgb'][2], + 3 => $values['valid'] ? $values['hsl'] : false + ]; + } + return $list; + } + + /** + * Undocumented function + * + * @return array + */ + public function hsl2rgbColorProvider(): array + { + $list = []; + foreach ($this->rgb2hslAndhsbList() as $name => $values) { + $list[$name . ', hsl to rgb'] = [ + 0 => $values['hsl'][0], + 1 => $values['hsl'][1], + 2 => $values['hsl'][2], + 3 => $values['valid'] ? $values['rgb'] : false + ]; + } + return $list; + } + + /** + * Undocumented function + * TODO: add cross convert check + * + * @dataProvider rgb2hexColorProvider + * @testdox rgb2hex $input_r,$input_g,$input_b will be $expected [$_dataName] + * + * @param int $input_r + * @param int $input_g + * @param int $input_b + * @param string|bool $expected + * @return void + */ + public function testRgb2hex(int $input_r, int $input_g, int $input_b, $expected_hash, $expected) + { + // with # + $this->assertEquals( + $expected_hash, + \CoreLibs\Convert\Colors::rgb2hex($input_r, $input_g, $input_b) + ); + // without # + $this->assertEquals( + $expected, + \CoreLibs\Convert\Colors::rgb2hex($input_r, $input_g, $input_b, false) + ); + // cross convert must match + // $rgb = \CoreLibs\Convert\Colors::hex2rgb($expected_hash); + // if ($rgb === false) { + // $rgb = [ + // 'r' => $input_r, + // 'g' => $input_g, + // 'b' => $input_b, + // ]; + // } + // $this->assertEquals( + // $expected_hash, + // \CoreLibs\Convert\Colors::rgb2hex($rgb['r'], $rgb['g'], $rgb['b']) + // ); + } + + /** + * Undocumented function + * + * @dataProvider hex2rgbColorProvider + * @testdox hex2rgb $input will be $expected, $expected_str str[,], $expected_str_sep str[$separator] [$_dataName] + * + * @param string $input + * @param array|bool $expected + * @param string|bool $expected_str + * @param string $separator + * @param string|bool $expected_str_sep + * @return void + */ + public function testHex2rgb( + string $input, + $expected, + $expected_str, + string $separator, + $expected_str_sep + ): void { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Colors::hex2rgb($input) + ); + $this->assertEquals( + $expected_str, + \CoreLibs\Convert\Colors::hex2rgb($input, true) + ); + $this->assertEquals( + $expected_str_sep, + \CoreLibs\Convert\Colors::hex2rgb($input, true, $separator) + ); + } + + /** + * Undocumented function + * + * @dataProvider rgb2hsbColorProvider + * @testdox rgb2hsb $input_r,$input_g,$input_b will be $expected [$_dataName] + * + * @param integer $input_r + * @param integer $input_g + * @param integer $input_b + * @param array|bool $expected + * @return void + */ + public function testRgb2hsb(int $input_r, int $input_g, int $input_b, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Colors::rgb2hsb($input_r, $input_g, $input_b) + ); + } + + /** + * Undocumented function + * + * @dataProvider hsb2rgbColorProvider + * @testdox hsb2rgb $input_h,$input_s,$input_b will be $expected [$_dataName] + * + * @param integer $input_h + * @param integer $input_s + * @param integer $input_b + * @param array|bool $expected + * @return void + */ + public function testHsb2rgb(int $input_h, int $input_s, int $input_b, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Colors::hsb2rgb($input_h, $input_s, $input_b) + ); + } + + /** + * Undocumented function + * + * @dataProvider rgb2hslColorProvider + * @testdox rgb2hsl $input_r,$input_g,$input_b will be $expected [$_dataName] + * + * @param integer $input_r + * @param integer $input_g + * @param integer $input_b + * @param array|bool $expected + * @return void + */ + public function testRgb2hsl(int $input_r, int $input_g, int $input_b, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Colors::rgb2hsl($input_r, $input_g, $input_b) + ); + } + + /** + * Undocumented function + * + * @dataProvider hsl2rgbColorProvider + * @testdox hsl2rgb $input_h,$input_s,$input_l will be $expected [$_dataName] + * + * @param integer|float $input_h + * @param integer $input_s + * @param integer $input_l + * @param array|bool $expected + * @return void + */ + public function testHsl2rgb($input_h, float $input_s, float $input_l, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Colors::hsl2rgb($input_h, $input_s, $input_l) + ); + } +} + +// __END__ diff --git a/4dev/tests/CoreLibsConvertHtmlTest.php b/4dev/tests/CoreLibsConvertHtmlTest.php new file mode 100644 index 00000000..1c4cacea --- /dev/null +++ b/4dev/tests/CoreLibsConvertHtmlTest.php @@ -0,0 +1,184 @@ + [ + 0 => 'I am some string', + 1 => 'I am some string', + ], + 'conversion' => [ + 0 => 'I have special <> inside', + 1 => 'I have special <> inside', + ], + 'skip number' => [ + 0 => 1234, + 1 => 1234, + ], + 'utf8' => [ + 0 => '日本語 <>', + 1 => '日本語 <>' + ] + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function removeLBProvider(): array + { + return [ + 'nothing replaced, default' => [ + 0 => 'I am some string', + 1 => null, + 2 => 'I am some string', + ], + 'string with \n replace -' => [ + 0 => "I am\nsome string", + 1 => '-', + 2 => 'I am-some string', + ], + 'string with \r replace _' => [ + 0 => "I am\rsome string", + 1 => '_', + 2 => 'I am_some string', + ], + 'string with \n\r, default' => [ + 0 => "I am\n\rsome string", + 1 => null, + 2 => 'I am some string', + ], + 'string with \n\r replae ##BR##' => [ + 0 => "I am\n\rsome string", + 1 => '##BR##', + 2 => 'I am##BR##some string', + ] + ]; + } + + /** + * Undocumented function + * + * @return array + */ + public function checkedProvider(): array + { + return [ + 'haystack is a string and matching selected' => [ + 0 => 'string', + 1 => 'string', + 2 => \CoreLibs\Convert\Html::SELECTED, + 3 => 'selected' + ], + 'haystack is a string and matching checked' => [ + 0 => 'string', + 1 => 'string', + 2 => \CoreLibs\Convert\Html::CHECKED, + 3 => 'checked' + ], + 'haystack is a string and not matching' => [ + 0 => 'string', + 1 => 'not matching', + 2 => \CoreLibs\Convert\Html::CHECKED, + 3 => null + ], + 'haystack is array and matching' => [ + 0 => ['a', 'b', 'c'], + 1 => 'a', + 2 => \CoreLibs\Convert\Html::SELECTED, + 3 => 'selected' + ], + 'haystack is array and not matching' => [ + 0 => ['a', 'b', 'c'], + 1 => 'not matching', + 2 => \CoreLibs\Convert\Html::SELECTED, + 3 => null + ], + ]; + } + + /** + * Undocumented function + * + * @dataProvider htmlentProvider + * @testdox htmlent $input will be $expected [$_dataName] + * + * @param mixed $input + * @param mixed $expected + * @return void + */ + public function testHtmlent($input, $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Html::htmlent($input) + ); + } + + /** + * Undocumented function + * + * @dataProvider removeLBProvider + * @testdox removeLB $input with replace $replace will be $expected [$_dataName] + * + * @param string $input + * @param string|null $replace + * @param string $expected + * @return void + */ + public function testRemoveLB(string $input, ?string $replace, string $expected): void + { + if ($replace !== null) { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Html::removeLB($input, $replace) + ); + } else { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Html::removeLB($input) + ); + } + } + + /** + * Undocumented function + * + * @dataProvider checkedProvider + * @testdox checked find $needle in $haystack and return $type will be $expected [$_dataName] + * + * @param array|string $haystack + * @param string $needle + * @param integer $type + * @param string|null $expected + * @return void + */ + public function testChecked($haystack, string $needle, int $type, ?string $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Html::checked($haystack, $needle, $type) + ); + } +} + +// __END__ diff --git a/4dev/tests/CoreLibsConvertJsonTest.php b/4dev/tests/CoreLibsConvertJsonTest.php new file mode 100644 index 00000000..4fc4b375 --- /dev/null +++ b/4dev/tests/CoreLibsConvertJsonTest.php @@ -0,0 +1,164 @@ + [ + '{"m":2,"f":"sub_2"}', + false, + [ + 'm' => 2, + 'f' => 'sub_2' + ] + ], + 'empty json' => [ + '', + false, + [] + ], + 'invalid json override' => [ + 'not valid', + true, + [ + 'not valid' + ] + ], + 'invalid json' => [ + 'not valid', + false, + [] + ], + 'null json' => [ + null, + false, + [] + ] + ]; + } + + /** + * json error list + * + * @return array JSON error list + */ + public function jsonErrorProvider(): array + { + return [ + 'no error' => [ + '{}', + JSON_ERROR_NONE, '' + ], + 'depth error' => [ + '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[' + . '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[' + . '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[' + . '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[' + . '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[' + . '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[' + . '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[' + . '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[' + . '[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' + . ']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' + . ']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' + . ']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' + . ']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' + . ']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' + . ']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' + . ']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' + . ']]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]' + . ']]]]', + JSON_ERROR_DEPTH, 'Maximum stack depth exceeded' + ], + // 'state mismatch error' => [ + // '{foo:}', + // JSON_ERROR_STATE_MISMATCH, 'Underflow or the modes mismatch' + // ], + // 'ctrl char error' => [ + // ' {"data":"data","data":"data","data":"data","data":"data"}', + // JSON_ERROR_CTRL_CHAR, 'Unexpected control character found' + // ], + 'syntax error' => [ + 'not valid', + JSON_ERROR_SYNTAX, 'Syntax error, malformed JSON' + ], + // 'utf8 error' => [ + // '{"invalid":"\xB1\x31"}', + // JSON_ERROR_UTF8, 'Malformed UTF-8 characters, possibly incorrectly encoded' + // ], + // 'invalid property' => [ + // '{"\u0000":"abc"}', + // JSON_ERROR_INVALID_PROPERTY_NAME, 'A key starting with \u0000 character was in the string' + // ], + // 'utf-16 error' => [ + // '', + // JSON_ERROR_UTF16, 'Single unpaired UTF-16 surrogate in unicode escape' + // ], + // 'unknown error' => [ + // '', + // -999999, 'Unknown error' + // ] + ]; + } + + /** + * test json convert states + * + * @dataProvider jsonProvider + * @testdox jsonConvertToArray $input (Override: $flag) will be $expected [$_dataName] + * + * @param string|null $input + * @param bool $flag + * @param array $expected + * @return void + */ + public function testJsonConvertToArray(?string $input, bool $flag, array $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Convert\Json::jsonConvertToArray($input, $flag) + ); + } + + /** + * test json error states + * + * @dataProvider jsonErrorProvider + * @testdox jsonGetLastError $input will be $expected_i/$expected_s [$_dataName] + * + * @param string|null $input + * @param string $expected + * @return void + */ + public function testJsonGetLastError(?string $input, int $expected_i, string $expected_s): void + { + \CoreLibs\Convert\Json::jsonConvertToArray($input); + $this->assertEquals( + $expected_i, + \CoreLibs\Convert\Json::jsonGetLastError() + ); + $this->assertEquals( + $expected_s, + \CoreLibs\Convert\Json::jsonGetLastError(true) + ); + } +} + +// __END__ diff --git a/4dev/tests/CoreLibsConvertMathTest.php b/4dev/tests/CoreLibsConvertMathTest.php index 220fc06e..c5d91689 100644 --- a/4dev/tests/CoreLibsConvertMathTest.php +++ b/4dev/tests/CoreLibsConvertMathTest.php @@ -30,7 +30,7 @@ final class CoreLibsConvertMathTest extends TestCase * Undocumented function * * @dataProvider fceilProvider - * @testdox Math::fceil: Input $input must be $expected + * @testdox fceil: Input $input must be $expected * * @param float $input * @param int $expected @@ -61,7 +61,7 @@ final class CoreLibsConvertMathTest extends TestCase * Undocumented function * * @dataProvider floorProvider - * @testdox Math::floor: Input $input with cutoff $cutoff must be $expected + * @testdox floor: Input $input with cutoff $cutoff must be $expected * * @param int $input * @param int $cutoff @@ -95,7 +95,7 @@ final class CoreLibsConvertMathTest extends TestCase * Undocumented function * * @dataProvider initNumericProvider - * @testdox Math::initNumeric: Input $info $input must match $expected [$_dataName] + * @testdox initNumeric: Input $info $input must match $expected [$_dataName] * * @param int|float|string $input * @param float $expected @@ -113,7 +113,7 @@ final class CoreLibsConvertMathTest extends TestCase /** * A testWith sample * - * @testdox Math::initNumeric: alternate tests $input => $expected ($info) [$_dataName] + * @testdox initNumeric: alternate tests $input => $expected ($info) [$_dataName] * @testWith [123.123, 123.123, "float"] * ["123.123", 123.123, "string"] * diff --git a/4dev/tests/CoreLibsConvertMimeAppNameTest.php b/4dev/tests/CoreLibsConvertMimeAppNameTest.php new file mode 100644 index 00000000..24eb9e1d --- /dev/null +++ b/4dev/tests/CoreLibsConvertMimeAppNameTest.php @@ -0,0 +1,57 @@ + [ + 0 => 'foo/bar', + 1 => 'FooBar Application', + 2 => 'FooBar Application', + ], + 'try to set empty mime type' => [ + 0 => '', + 1 => 'Some app', + 2 => 'Other file' + ], + 'try to set empty app name' => [ + 0 => 'some/app', + 1 => '', + 2 => 'Other file' + ], + ]; + } + + /** + * Undocumented function + * + * @dataProvider mimeProvider + * @testdox mimeSetAppName set $mime with $app and will be $expected [$_dataName] + * + * @param string $mime + * @param string $app + * @return void + */ + public function testMimeSetAppName(string $mime, string $app, string $expected): void + { + \CoreLibs\Convert\MimeAppName::mimeSetAppName($mime, $app); + $this->assertEquals( + $expected, + \CoreLibs\Convert\MimeAppName::mimeGetAppName($mime) + ); + } +} + +// __END__ diff --git a/4dev/tests/CoreLibsCreateHashTest.php b/4dev/tests/CoreLibsCreateHashTest.php new file mode 100644 index 00000000..815d7823 --- /dev/null +++ b/4dev/tests/CoreLibsCreateHashTest.php @@ -0,0 +1,64 @@ + [ + 'text' => 'Some String Text', + 'crc32b_reverse' => 'c5c21d91', // crc32b (in revere) + 'sha1Short' => '', // sha1Short + // via hash + 'crc32b' => '', // hash: crc32b + 'alder32' => '', // hash: alder32 + 'fnv132' => '', // hash: fnv132 + 'fnv1a32' => '', // hash: fnv1a32 + 'joaat' => '', // hash: joaat + ] + ]; + } + + public function crc32bProvider(): array + { + $list = []; + foreach ($this->hashProvider() as $name => $values) { + $list[$name . ' to crc32b reverse'] = [ + 0 => $values['text'], + 1 => $values['crc32b_reverse'], + ]; + } + return $list; + } + + /** + * Undocumented function + * + * @dataProvider crc32bProvider + * @testdox __crc32b $input will be $expected [$_dataName] + * + * @param string $input + * @param string $expected + * @return void + */ + public function testCrc32b(string $input, string $expected): void + { + $this->assertEquals( + $expected, + \CoreLibs\Create\Hash::__crc32b($input) + ); + } +} + +// __END__ diff --git a/4dev/tests/phpunit_flow_check.php b/4dev/tests/phpunit_flow_check.php new file mode 100644 index 00000000..bbe2d5da --- /dev/null +++ b/4dev/tests/phpunit_flow_check.php @@ -0,0 +1,58 @@ +assertTrue(true); + } + + public function testTwo(): void + { + fwrite(STDOUT, __METHOD__ . "\n"); + $this->assertTrue(false); + } + + protected function assertPostConditions(): void + { + fwrite(STDOUT, __METHOD__ . "\n"); + } + + protected function tearDown(): void + { + fwrite(STDOUT, __METHOD__ . "\n"); + } + + public static function tearDownAfterClass(): void + { + fwrite(STDOUT, __METHOD__ . "\n"); + } + + protected function onNotSuccessfulTest(\Throwable $t): void + { + fwrite(STDOUT, __METHOD__ . "\n"); + throw $t; + } +}