CoreLibs/development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add PHP unit tests

Browse Source 
Check\*
Combined\*
Convert\*
Create\Hash (stub)
This commit is contained in:
Clemens Schwaighofer
2022-01-11 19:58:33 +09:00
parent 5452bffdb4
commit 7fd5062064
14 changed files with 2697 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
4dev/tests/CoreLibsCheckEmailTest.php
View File

@@ -41,7 +41,7 @@ final class CoreLibsCheckEmailTest extends TestCase
* Test regex level return * Test regex level return
* *
* @dataProvider emailRegexProvider * @dataProvider emailRegexProvider
* @testdox Email::getEmailRegex $input will be $expected [$_dataName] * @testdox getEmailRegex $input will be $expected [$_dataName]
* *
* @param int $input * @param int $input
* @param string $expected * @param string $expected
@@ -94,7 +94,7 @@ final class CoreLibsCheckEmailTest extends TestCase
* Undocumented function * Undocumented function
* *
* @dataProvider emailCheckProvider * @dataProvider emailCheckProvider
* @testdox Email::checkEmail $input will be $expected [$_dataName] * @testdox checkEmail $input will be $expected [$_dataName]
* *
* @return void * @return void
*/ */
@@ -125,7 +125,7 @@ final class CoreLibsCheckEmailTest extends TestCase
* Undocumented function * Undocumented function
* *
* @dataProvider emailCheckFullProvider * @dataProvider emailCheckFullProvider
* @testdox Email::checkEmailFull $input will be $expected [$_dataName] * @testdox checkEmailFull $input will be $expected [$_dataName]
* *
* @param string $input * @param string $input
* @param array $expected * @param array $expected
@@ -219,7 +219,7 @@ final class CoreLibsCheckEmailTest extends TestCase
* Undocumented function * Undocumented function
* *
* @dataProvider emailRegexErrorProvider * @dataProvider emailRegexErrorProvider
* @testdox Email::getEmailRegexErrorMessage $input will be $expected [$_dataName] * @testdox getEmailRegexErrorMessage $input will be $expected [$_dataName]
* *
* @param integer $input * @param integer $input
* @param array $expected * @param array $expected
@@ -283,7 +283,7 @@ final class CoreLibsCheckEmailTest extends TestCase
* Undocumented function * Undocumented function
* *
* @dataProvider emailTypeProviderLong * @dataProvider emailTypeProviderLong
* @testdox Email::getEmailType $input will be normal $expected [$_dataName] * @testdox getEmailType $input will be normal $expected [$_dataName]
* *
* @param string $input * @param string $input
* @param string $expected * @param string $expected
@@ -301,7 +301,7 @@ final class CoreLibsCheckEmailTest extends TestCase
* Undocumented function * Undocumented function
* *
* @dataProvider emailTypeProviderShort * @dataProvider emailTypeProviderShort
* @testdox Email::getEmailType $input will be short $expected [$_dataName] * @testdox getEmailType $input will be short $expected [$_dataName]
* *
* @param string $input * @param string $input
* @param string $expected * @param string $expected
@@ -355,7 +355,7 @@ final class CoreLibsCheckEmailTest extends TestCase
* Undocumented function * Undocumented function
* *
* @dataProvider emailProviderTypeLongToShort * @dataProvider emailProviderTypeLongToShort
* @testdox Email::getShortEmailType $input will be $expected [$_dataName] * @testdox getShortEmailType $input will be $expected [$_dataName]
* *
* @param string $input * @param string $input
* @param string|bool $expected * @param string|bool $expected

92
4dev/tests/CoreLibsCheckFileTest.php
View File

@@ -7,40 +7,42 @@ namespace tests;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
/** /**
* Undocumented class * Test class for Check\File
* @testdox CoreLibs\Check\File method tests * @testdox CoreLibs\Check\File method tests
*/ */
final class CoreLibsCheckFileTest extends TestCase final class CoreLibsCheckFileTest extends TestCase
{ {
/** @var array<mixed> */ /** @var array<mixed> */
private $files = []; // private $files_list = [];
/** @var string */
protected function setUp(): void private $base_folder = DIRECTORY_SEPARATOR . 'tmp' . DIRECTORY_SEPARATOR;
{
// write a dummy files for testing
}
protected function tearDown(): void
{
// unlink files
}
/** /**
* main file list + data provider * main file list + data provider
* *
* filename, file extension matching, lines in file, -1 for nothing
*
* @return array * @return array
*/ */
public function filesList(): array public function filesList(): array
{ {
return [ 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 public function filesExtensionProvider(): array
{ {
$list = []; $list = [];
foreach ($this->filesList as $row) { foreach ($this->filesList() as $row) {
$list[$row[0] . ' must be extension ' . $row[1]] = [$row[0], $row[1]]; $list[$row[0] . ' must be extension ' . $row[1]] = [$row[0], $row[1]];
} }
return $list; return $list;
@@ -49,40 +51,66 @@ final class CoreLibsCheckFileTest extends TestCase
/** /**
* Undocumented function * Undocumented function
* *
* @#dataProvider filesExtensionProvider * @return array
* @#testdox File::getFilenameEnding Input $input must be $expected */
* //string $input, string $expected 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 * @dataProvider filesExtensionProvider
* @param string $expected * @testdox getFilenameEnding $input must be extension $expected [$_dataName]
*
* @param string $input
* @param string $expected
* @return void * @return void
*/ */
public function testGetFilenameEnding(): void public function testGetFilenameEnding(string $input, string $expected): void
{ {
// getFilenameEnding // getFilenameEnding
/* $this->assertEquals( $this->assertEquals(
$expected, $expected,
\CoreLibs\Check\File::getFilenameEnding($input) \CoreLibs\Check\File::getFilenameEnding($input)
); */
$this->assertTrue(true, 'This should already work.');
$this->markTestIncomplete(
'testGetFilenameEnding has not been implemented yet.'
); );
} }
/** /**
* Undocumented function * Tests the file line read
* // string $input, string $expected
* *
* @dataProvider filesLinesProvider
* @testdox getLinesFromFile $input must have $expected lines [$_dataName]
*
* @param string $input file name
* @param int $expected lines in file
* @return void * @return void
*/ */
public function testGetLinesFromFile(): void public function testGetLinesFromFile(string $input, int $expected): void
{ {
// getLinesFromFile // create file
$this->assertTrue(true, 'This should already work.'); if ($expected > -1) {
$this->markTestIncomplete( $file = $this->base_folder . $input;
'testGetLinesFromFile has not been implemented yet.' $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);
}
} }
} }

69
4dev/tests/CoreLibsCheckPasswordTest.php Normal file
View File

@@ -0,0 +1,69 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Check\Password
* @testdox CoreLibs\Check\Password method tests
*/
final class CoreLibsCheckPasswordTest extends TestCase
{
public function passwordProvider(): array
{
return [
'matching password' => ['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__

62
4dev/tests/CoreLibsCheckPhpVersionTest.php Normal file
View File

@@ -0,0 +1,62 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Check\PHPVersion
* @testdox CoreLibs\Check\PHPVersion method tests
*/
final class CoreLibsCheckPHPVersionTest extends TestCase
{
/**
* NOTE: The checks must be adapted to the PHP version or they will fail
*
* @return array
*/
public function phpVersionProvider(): array
{
return [
// min
'min 7' => ['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__

773
4dev/tests/CoreLibsCombinedArrayHandlerTest.php Normal file
View File

@@ -0,0 +1,773 @@
<?php
// because we have long testdox lines
// phpcs:disable Generic.Files.LineLength
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Combined\ArrayHandler
* @testdox CoreLibs\Combined\ArrayHandler method tests
*/
final class CoreLibsCombinedArrayHandlerTest extends TestCase
{
// we use that for all
public static $array = [
'a' => [
'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__

596
4dev/tests/CoreLibsCombinedDateTimeTest.php Normal file
View File

@@ -0,0 +1,596 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Combined\DateTime
* @testdox CoreLibs\Combined\DateTime method tests
*/
final class CoreLibsCombinedDateTimeTest extends TestCase
{
/**
* timestamps
*
* @return array
*/
public function timestampProvider(): array
{
return [
'valid timestamp no microtime' => [
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__

219
4dev/tests/CoreLibsConvertByteTest.php Normal file
View File

@@ -0,0 +1,219 @@
<?php
// because we have long testdox lines
// phpcs:disable Generic.Files.LineLength
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\Byte
* @testdox CoreLibs\Convert\Byte method tests
*/
final class CoreLibsConvertByteTest extends TestCase
{
/**
* Undocumented function
*
* @return array
*/
public function byteProvider(): array
{
return [
'negative number' => [
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__

380
4dev/tests/CoreLibsConvertColorsTest.php Normal file
View File

@@ -0,0 +1,380 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\Colors
* @testdox CoreLibs\Convert\Colors method tests
*/
final class CoreLibsConvertColorsTest extends TestCase
{
// convert list
public static $colors = [];
/**
* Undocumented function
*
* @return array
*/
public function rgb2hexColorProvider(): array
{
return [
'color' => [
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__

184
4dev/tests/CoreLibsConvertHtmlTest.php Normal file
View File

@@ -0,0 +1,184 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\Html
* @testdox CoreLibs\Convert\Html method tests
*/
final class CoreLibsConvertHtmlTest extends TestCase
{
/**
* Undocumented function
*
* @return array
*/
public function htmlentProvider(): array
{
return [
'no conversion' => [
0 => 'I am some string',
1 => 'I am some string',
],
'conversion' => [
0 => 'I have special <> inside',
1 => 'I have special &lt;&gt; inside',
],
'skip number' => [
0 => 1234,
1 => 1234,
],
'utf8' => [
0 => '日本語 <>',
1 => '日本語 &lt;&gt;'
]
];
}
/**
* 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<mixed>|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__

164
4dev/tests/CoreLibsConvertJsonTest.php Normal file
View File

@@ -0,0 +1,164 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Check\Json
* @testdox CoreLibs\Convert\Json method tests
*/
final class CoreLibsCheckJsonTest extends TestCase
{
/**
* test list for json convert tests
*
* @return array
*/
public function jsonProvider(): array
{
return [
'valid json' => [
'{"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__

8
4dev/tests/CoreLibsConvertMathTest.php
View File

@@ -30,7 +30,7 @@ final class CoreLibsConvertMathTest extends TestCase
* Undocumented function * Undocumented function
* *
* @dataProvider fceilProvider * @dataProvider fceilProvider
* @testdox Math::fceil: Input $input must be $expected * @testdox fceil: Input $input must be $expected
* *
* @param float $input * @param float $input
* @param int $expected * @param int $expected
@@ -61,7 +61,7 @@ final class CoreLibsConvertMathTest extends TestCase
* Undocumented function * Undocumented function
* *
* @dataProvider floorProvider * @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 $input
* @param int $cutoff * @param int $cutoff
@@ -95,7 +95,7 @@ final class CoreLibsConvertMathTest extends TestCase
* Undocumented function * Undocumented function
* *
* @dataProvider initNumericProvider * @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 int|float|string $input
* @param float $expected * @param float $expected
@@ -113,7 +113,7 @@ final class CoreLibsConvertMathTest extends TestCase
/** /**
* A testWith sample * 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"] * @testWith [123.123, 123.123, "float"]
* ["123.123", 123.123, "string"] * ["123.123", 123.123, "string"]
* *

57
4dev/tests/CoreLibsConvertMimeAppNameTest.php Normal file
View File

@@ -0,0 +1,57 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\MimeAppName
* @testdox CoreLibs\Convert\MimeAppName method tests
*/
final class CoreLibsConvertMimeAppNameTest extends TestCase
{
public function mimeProvider(): array
{
return [
'find matching app' => [
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__

64
4dev/tests/CoreLibsCreateHashTest.php Normal file
View File

@@ -0,0 +1,64 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Create\Hash
* @testdox CoreLibs\Create\Hash method tests
*/
final class CoreLibsCreateHashTest extends TestCase
{
public function hashProvider(): array
{
return [
'any string' => [
'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__

58
4dev/tests/phpunit_flow_check.php Normal file
View File

@@ -0,0 +1,58 @@
<?php
declare(strict_types=1);
namespace test;
use PHPUnit\Framework\TestCase;
final class TemplateMethodsTest extends TestCase
{
public static function setUpBeforeClass(): void
{
fwrite(STDOUT, __METHOD__ . "\n");
}
protected function setUp(): void
{
fwrite(STDOUT, __METHOD__ . "\n");
}
protected function assertPreConditions(): void
{
fwrite(STDOUT, __METHOD__ . "\n");
}
public function testOne(): void
{
fwrite(STDOUT, __METHOD__ . "\n");
$this->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;
}
}