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

Move all tests into sub folders for a more clear structure

Browse Source
This commit is contained in:
Clemens Schwaighofer
2023-03-02 11:51:29 +09:00
parent 1596654149
commit b992901072
63 changed files with 75 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

887
4dev/tests/Combined/CoreLibsCombinedArrayHandlerTest.php Normal file
View File

@@ -0,0 +1,887 @@
<?php
// because we have long testdox lines
// phpcs:disable Generic.Files.LineLength
declare(strict_types=1);
namespace tests;
use Exception;
use PHPUnit\Framework\TestCase;
/**
* Test class for Combined\ArrayHandler
* @coversDefaultClass \CoreLibs\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
{
/*
0: $needle,
1: array $input,
2: ?string $key_search_for,
3: bool $flag,
4: array $expected
*/
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
{
/*
0: array $input,
1: $key,
2: $value,
3: bool $flag,
4: bool $expected
*/
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,
],
];
}
/**
* provides array listing for the merge test
*
* @return array
*/
public function arrayMergeRecursiveProvider(): array
{
return [
// 0: expected
// 1..n: to merge arrays
// n+1: trigger for handle keys as string
'two arrays' => [
['a' => 1, 'b' => 2, 'c' => 3],
['a' => 1, 'b' => 2],
['b' => 2, 'c' => 3],
],
'two arrays, string flag' => [
['a' => 1, 'b' => 2, 'c' => 3],
['a' => 1, 'b' => 2],
['b' => 2, 'c' => 3],
true,
],
// non hash arrays
'non hash array merge, no string flag' => [
[3, 4, 5],
[1, 2, 3],
[3, 4, 5],
],
'non hash array merge, string flag' => [
[1, 2, 3, 3, 4, 5],
[1, 2, 3],
[3, 4, 5],
true
],
];
}
/**
* for warning checks
*
* @return array
*/
public function arrayMergeRecursiveProviderWarning(): array
{
return [
// error <2 arguments
'too view arguments' => [
'arrayMergeRecursive needs two or more array arguments',
[1]
],
// error <2 arrays
'only one array' => [
'arrayMergeRecursive needs two or more array arguments',
[1],
true,
],
// error element is not array
'non array between array' => [
'arrayMergeRecursive encountered a non array argument',
[1],
'string',
[2]
],
];
}
/**
* 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
*
* @covers ::arraySearchRecursive
* @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
*
* @covers ::arraySearchRecursiveAll
* @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
*
* @covers ::arraySearchSimple
* @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|bool $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
*
* @covers ::arrayMergeRecursive
* @dataProvider arrayMergeRecursiveProvider
* @testdox arrayMergeRecursive ... [$_dataName]
*
* @return void
*
*/
public function testArrayMergeRecursive(): void
{
$arrays = func_get_args();
// first is expected array, always
$expected = array_shift($arrays);
$output = \CoreLibs\Combined\ArrayHandler::arrayMergeRecursive(
...$arrays
);
$this->assertEquals(
$expected,
$output
);
}
/**
* Undocumented function
*
* @covers ::arrayMergeRecursive
* @dataProvider arrayMergeRecursiveProviderWarning
* @testdox arrayMergeRecursive with E_USER_WARNING [$_dataName]
*
* @return void
*/
public function testArrayMergeRecursiveWarningA(): void
{
set_error_handler(
static function (int $errno, string $errstr): never {
throw new Exception($errstr, $errno);
},
E_USER_WARNING
);
$arrays = func_get_args();
// first is expected warning
$warning = array_shift($arrays);
// phpunit 10.0 compatible
$this->expectExceptionMessage(($warning));
\CoreLibs\Combined\ArrayHandler::arrayMergeRecursive(...$arrays);
restore_error_handler();
}
/**
* Undocumented function
*
* @covers ::arrayDiff
* @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
*
* @covers ::inArrayAny
* @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
*
* @covers ::genAssocArray
* @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
*
* @covers ::flattenArray
* @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
*
* @covers ::flattenArrayKey
* @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
*
* @covers ::flattenArrayKeyLeavesOnly
* @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
*
* @covers ::arrayFlatForKey
* @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__

785
4dev/tests/Combined/CoreLibsCombinedDateTimeTest.php Normal file
View File

@@ -0,0 +1,785 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Combined\DateTime
* @coversDefaultClass \CoreLibs\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,
false,
'2022-01-07 09:38:10',
],
'valid timestamp with microtime' => [
1641515890,
true,
false,
'2022-01-07 09:38:10',
],
'valid timestamp with microtime float' => [
1641515890,
true,
true,
'2022-01-07 09:38:10',
],
'valid micro timestamp with microtime' => [
1641515890.123456,
true,
false,
'2022-01-07 09:38:10 1235ms',
],
'valid micro timestamp with microtime float' => [
1641515890.123456,
true,
true,
'2022-01-07 09:38:10.1235',
],
'valid micro timestamp no microtime' => [
1641515890.123456,
false,
false,
'2022-01-07 09:38:10',
],
'invalid timestamp' => [
-123123,
false,
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
*
* @covers ::dateStringFormat
* @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_show_micro,
bool $flag_micro_as_float,
string $expected
): void {
$this->assertEquals(
$expected,
\CoreLibs\Combined\DateTime::dateStringFormat(
$input,
$flag_show_micro,
$flag_micro_as_float
)
);
}
/**
* interval convert test
*
* @covers ::timeStringFormat
* @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
*
* @covers ::stringToTime
* @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
*
* @covers ::checkDate
* @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
*
* @covers ::checkDateTime
* @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
*
* @covers ::compareDate
* @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
*
* @covers ::compareDateTime
* @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
*
* @covers ::calcDaysInterval
* @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)
);
}
/**
* Undocumented function
*
* @return array
*/
public function weekdayNumberProvider(): array
{
return [
'0 invalid' => [0, null, 'Inv',],
'0 invalid long' => [0, true, 'Invalid',],
'1 short' => [1, null, 'Mon',],
'1 long' => [1, true, 'Monday',],
'2 short' => [2, null, 'Tue',],
'2 long' => [2, true, 'Tuesday',],
'3 short' => [3, null, 'Wed',],
'3 long' => [3, true, 'Wednesday',],
'4 short' => [4, null, 'Thu',],
'4 long' => [4, true, 'Thursday',],
'5 short' => [5, null, 'Fri',],
'5 long' => [5, true, 'Friday',],
'6 short' => [6, null, 'Sat',],
'6 long' => [6, true, 'Saturday',],
'7 short' => [7, null, 'Sun',],
'7 long' => [7, true, 'Sunday',],
'8 invalid' => [8, null, 'Inv',],
'8 invalid long' => [8, true, 'Invalid',],
];
}
/**
* int weekday number to string weekday
*
* @covers ::setWeekdayNameFromIsoDow
* @dataProvider weekdayNumberProvider
* @testdox weekdayListProvider $input (short $flag) will be $expected [$_dataName]
*
* @param int $input
* @param bool|null $flag
* @param string $expected
* @return void
*/
public function testSetWeekdayNameFromIsoDow(
int $input,
?bool $flag,
string $expected
): void {
if ($flag === null) {
$output = \CoreLibs\Combined\DateTime::setWeekdayNameFromIsoDow($input);
} else {
$output = \CoreLibs\Combined\DateTime::setWeekdayNameFromIsoDow($input, $flag);
}
$this->assertEquals(
$expected,
$output
);
}
/**
* Undocumented function
*
* @return array
*/
public function weekdayDateProvider(): array
{
return [
'invalid date' => ['2022-02-31', -1],
'1: monday' => ['2022-07-25', 1],
'2: tuesday' => ['2022-07-26', 2],
'3: wednesday' => ['2022-07-27', 3],
'4: thursday' => ['2022-07-28', 4],
'5: friday' => ['2022-07-29', 5],
'6: saturday' => ['2022-07-30', 6],
'7: sunday' => ['2022-07-31', 7],
];
}
/**
* date to weekday number
*
* @covers ::setWeekdayNumberFromDate
* @dataProvider weekdayDateProvider
* @testdox setWeekdayNumberFromDate $input will be $expected [$_dataName]
*
* @param string $input
* @param int $expected
* @return void
*/
public function testSetWeekdayNumberFromDate(
string $input,
int $expected
): void {
$this->assertEquals(
$expected,
\CoreLibs\Combined\DateTime::setWeekdayNumberFromDate($input)
);
}
/**
* Undocumented function
*
* @return array
*/
public function weekdayDateNameProvider(): array
{
return [
'invalid date short' => ['2022-02-31', null, 'Inv'],
'invalid date long' => ['2022-02-31', true, 'Invalid'],
'Mon short' => ['2022-07-25', null, 'Mon'],
'Monday long' => ['2022-07-25', true, 'Monday'],
'Tue short' => ['2022-07-26', null, 'Tue'],
'Tuesday long' => ['2022-07-26', true, 'Tuesday'],
'Wed short' => ['2022-07-27', null, 'Wed'],
'Wednesday long' => ['2022-07-27', true, 'Wednesday'],
'Thu short' => ['2022-07-28', null, 'Thu'],
'Thursday long' => ['2022-07-28', true, 'Thursday'],
'Fri short' => ['2022-07-29', null, 'Fri'],
'Friday long' => ['2022-07-29', true, 'Friday'],
'Sat short' => ['2022-07-30', null, 'Sat'],
'Saturday long' => ['2022-07-30', true, 'Saturday'],
'Sun short' => ['2022-07-31', null, 'Sun'],
'Sunday long' => ['2022-07-31', true, 'Sunday'],
];
}
/**
* date to weekday name
*
* @covers ::setWeekdayNameFromDate
* @dataProvider weekdayDateNameProvider
* @testdox setWeekdayNameFromDate $input (short $flag) will be $expected [$_dataName]
*
* @param string $input
* @param bool|null $flag
* @param string $expected
* @return void
*/
public function testSetWeekdayNameFromDate(
string $input,
?bool $flag,
string $expected
): void {
if ($flag === null) {
$output = \CoreLibs\Combined\DateTime::setWeekdayNameFromDate($input);
} else {
$output = \CoreLibs\Combined\DateTime::setWeekdayNameFromDate($input, $flag);
}
$this->assertEquals(
$expected,
$output
);
}
}
// __END__