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

280
4dev/tests/Convert/CoreLibsConvertByteTest.php Normal file
View File

@@ -0,0 +1,280 @@
<?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
* @coversDefaultClass \CoreLibs\Convert\Byte
* @testdox \CoreLibs\Convert\Byte method tests
*/
final class CoreLibsConvertByteTest extends TestCase
{
/**
* Undocumented function
*
* @return array
*/
public function byteProvider(): array
{
/*
* 0: input string
* 1: default flags
* 2: BYTE_FORMAT_SI
* 3: BYTE_FORMAT_NOSPACE
* 4: BYTE_FORMAT_ADJUST
* 5: BYTE_FORMAT_SI | BYTE_FORMAT_NOSPACE
*/
return [
'string number' => [
0 => '1024',
1 => '1 KB',
2 => '1.02 KiB',
3 => '1KB',
4 => '1.00 KB',
5 => '1.02KiB',
],
'invalud string number' => [
0 => '1024 MB',
1 => '1024 MB',
2 => '1024 MB',
3 => '1024 MB',
4 => '1024 MB',
5 => '1024 MB',
],
'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
*
* @covers ::humanReadableByteFormat
* @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
*
* @covers ::stringByteFormat
* @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)
);
}
/**
* Exceptions tests
*
* @covers ::humanReadableByteFormat
* @testWith [99]
* @testdox Test exception for humanReadableByteFormat with flag $flag
*
* @param int $flag
* @return void
*/
public function testHumanReadableByteFormatException(int $flag): void
{
$this->expectException(\Exception::class);
\CoreLibs\Convert\Byte::humanReadableByteFormat(12, $flag);
}
/**
* Exceptions tests
* can only be 4, try 1,2 and over
*
* @covers ::stringByteFormat
* @testWith [1]
* [2]
* [99]
* @testdox Test exception for stringByteFormat with flag $flag
*
* @param int $flag
* @return void
*/
public function testStringByteFormatException(int $flag): void
{
$this->expectException(\Exception::class);
\CoreLibs\Convert\Byte::stringByteFormat(12, $flag);
}
}
// __END__

420
4dev/tests/Convert/CoreLibsConvertColorsTest.php Normal file
View File

@@ -0,0 +1,420 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\Colors
* @coversDefaultClass \CoreLibs\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
{
// if hsb_from or hsl_from is set, this will be used in hsb/hsl convert
// hsb_rgb is used for adjusted rgb valus due to round error to in
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.0],
'hsb_rgb' => [10, 98, 199], // should be rgb, but rounding error
'hsl' => [211.6, 90.5, 41.2],
'valid' => true,
],
// hsg/hsl with 360 which is seen as 0
'valid color hue 360' => [
'rgb' => [200, 10, 10],
'hsb' => [0, 95, 78.0],
'hsb_from' => [360, 95, 78.0],
'hsb_rgb' => [199, 10, 10], // should be rgb, but rounding error
'hsl' => [0.0, 90.5, 41.2],
'hsl_from' => [360.0, 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_from'][0] ?? $values['hsb'][0],
1 => $values['hsb_from'][1] ?? $values['hsb'][1],
2 => $values['hsb_from'][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_from'][0] ?? $values['hsl'][0],
1 => $values['hsl_from'][1] ?? $values['hsl'][1],
2 => $values['hsl_from'][2] ?? $values['hsl'][2],
3 => $values['valid'] ? $values['rgb'] : false
];
}
return $list;
}
/**
* Undocumented function
* TODO: add cross convert check
*
* @covers ::rgb2hex
* @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
*
* @covers ::hex2rgb
* @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
*
* @covers ::rgb2hsb
* @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
*
* @covers ::hsb2rgb
* @dataProvider hsb2rgbColorProvider
* @testdox hsb2rgb $input_h,$input_s,$input_b will be $expected [$_dataName]
*
* @param float $input_h
* @param float $input_s
* @param float $input_b
* @param array|bool $expected
* @return void
*/
public function testHsb2rgb(float $input_h, float $input_s, float $input_b, $expected): void
{
$this->assertEquals(
$expected,
\CoreLibs\Convert\Colors::hsb2rgb($input_h, $input_s, $input_b)
);
}
/**
* Undocumented function
*
* @covers ::rgb2hsl
* @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
*
* @covers ::hsl2rgb
* @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)
);
}
/**
* edge case check hsl/hsb and hue 360 (= 0)
*
* @covers ::hsl2rgb
* @covers ::hsb2rgb
* @testdox hsl2rgb/hsb2rgb hue 360 valid check
*
* @return void
*/
public function testHslHsb360hue(): void
{
$this->assertNotFalse(
\CoreLibs\Convert\Colors::hsl2rgb(360.0, 90.5, 41.2),
'HSL to RGB with 360 hue'
);
$this->assertNotFalse(
\CoreLibs\Convert\Colors::hsb2rgb(360, 95, 78.0),
'HSB to RGB with 360 hue'
);
}
}
// __END__

102
4dev/tests/Convert/CoreLibsConvertEncodingTest.php Normal file
View File

@@ -0,0 +1,102 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\Encoding
* @coversDefaultClass \CoreLibs\Convert\Encoding
* @testdox \CoreLibs\Convert\Encoding method tests
*/
final class CoreLibsConvertEncodingTest extends TestCase
{
/**
* Undocumented function
*
* @return array
*/
public function convertEncodingProvider(): array
{
return [
// 0: original string
// 1: target encoding
// 2: optional source encoding
// 3: auto check (not used)
// 4: expected string
// 5: expected string encoding
'simple from UTF-8 to SJIS' => [
'input string',
'SJIS',
null,
null,
'input string',
'SJIS'
],
'kanji from UTF-8 to SJIS' => [
'日本語',
'SJIS',
null,
null,
'日本語',
'SJIS'
],
'kanji from UTF-8 to SJIS with source' => [
'日本語',
'SJIS',
'UTF-8',
null,
'日本語',
'SJIS'
],
];
}
/**
* Undocumented function
*
* @covers ::convertEncoding
* @dataProvider convertEncodingProvider
* @testdox convert encoding $target_encoding, source: $source_encoding, auto: $auto_check [$_dataName]
*
* @param string $input
* @param string $target_encoding
* @param string $source_encoding
* @param bool $auto_check
* @param string $expected
* @param string $expected_encoding
* @return void
*/
public function testConvertEncoding(
string $input,
string $target_encoding,
?string $source_encoding,
?bool $auto_check,
string $expected,
string $expected_encoding
): void {
if ($source_encoding === null and $auto_check === null) {
$string = \CoreLibs\Convert\Encoding::convertEncoding($input, $target_encoding);
} elseif ($auto_check === null) {
$string = \CoreLibs\Convert\Encoding::convertEncoding($input, $target_encoding, $source_encoding);
} else {
$string = \CoreLibs\Convert\Encoding::convertEncoding(
$input,
$target_encoding,
$source_encoding,
$auto_check
);
}
// because we can't store encoding in here anyway
$target = mb_convert_encoding($expected, $expected_encoding, 'UTF-8');
// print "IN: $input, $target_encoding\n";
$this->assertEquals(
$target,
$string
);
}
}
// __END__

188
4dev/tests/Convert/CoreLibsConvertHtmlTest.php Normal file
View File

@@ -0,0 +1,188 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\Html
* @coversDefaultClass \CoreLibs\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
*
* @covers ::htmlent
* @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
*
* @covers ::removeLB
* @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
*
* @covers ::checked
* @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__

166
4dev/tests/Convert/CoreLibsConvertJsonTest.php Normal file
View File

@@ -0,0 +1,166 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Check\Json
* @coversDefaultClass \CoreLibs\Convert\Json
* @testdox \CoreLibs\Convert\Json method tests
*/
final class CoreLibsConvertJsonTest 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
*
* @covers ::jsonConvertToArray
* @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
*
* @covers ::jsonGetLastError
* @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__

118
4dev/tests/Convert/CoreLibsConvertMathTest.php Normal file
View File

@@ -0,0 +1,118 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Undocumented class
* @coversDefaultClass \CoreLibs\Convert\Math
* @testdox \CoreLibs\Convert\Math method tests
*/
final class CoreLibsConvertMathTest extends TestCase
{
/**
* Undocumented function
*
* @return array<mixed>
*/
public function fceilProvider(): array
{
return [
'5.5 must be 6' => [5.5, 6],
'5.1234567890 with 5 must be 6' => [5.1234567890, 6],
'6 must be 6' => [6, 6]
];
}
/**
* Undocumented function
*
* @covers ::fceil
* @dataProvider fceilProvider
* @testdox fceil: Input $input must be $expected
*
* @param float $input
* @param int $expected
* @return void
*/
public function testMathFceilValue(float $input, int $expected): void
{
$this->assertEquals(
$expected,
\CoreLibs\Convert\Math::fceil($input)
);
}
/**
* Undocumented function
*
* @return array<mixed>
*/
public function floorProvider(): array
{
return [
'5123456 with -3 must be 5123000' => [5123456, -3, 5123000],
'5123456 with -10 must be 5000000' => [5123456, -10, 5000000]
];
}
/**
* Undocumented function
*
* @covers ::floorp
* @dataProvider floorProvider
* @testdox floor: Input $input with cutoff $cutoff must be $expected
*
* @param int $input
* @param int $cutoff
* @param int $expected
* @return void
*/
public function testMathFloorValue(int $input, int $cutoff, int $expected): void
{
$this->assertEquals(
$expected,
\CoreLibs\Convert\Math::floorp($input, $cutoff)
);
}
/**
* Undocumented function
*
* @return array<mixed>
*/
public function initNumericProvider(): array
{
return [
'5 must be 5' => [5, 5, 'int'],
'5.123 must be 5.123' => [5.123, 5.123, 'float'],
"'5' must be 5" => ['5', 5, 'string'],
"'5.123' must be 5.123" => ['5.123', 5.123, 'string'],
];
}
/**
* Undocumented function
*
* @covers ::initNumeric
* @dataProvider initNumericProvider
* @testdox initNumeric: Input $info $input must match $expected [$_dataName]
*
* @param int|float|string $input
* @param float $expected
* @param string $info
* @return void
*/
public function testMathInitNumericValue($input, float $expected, string $info): void
{
$this->assertEquals(
$expected,
\CoreLibs\Convert\Math::initNumeric($input)
);
}
}
// __END__

60
4dev/tests/Convert/CoreLibsConvertMimeAppNameTest.php Normal file
View File

@@ -0,0 +1,60 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\MimeAppName
* @coversDefaultClass \CoreLibs\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
*
* @covers ::mimeGetAppName
* @covers ::mimeSetAppName
* @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__

101
4dev/tests/Convert/CoreLibsConvertMimeEncodeTest.php Normal file
View File

@@ -0,0 +1,101 @@
<?php
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\MimeEncode
* @coversDefaultClass \CoreLibs\Convert\MimeEncode
* @testdox \CoreLibs\Convert\MimeEncode method tests
*/
final class CoreLibsConvertMimeEncodeTest extends TestCase
{
/**
* Undocumented function
*
* @return array
*/
public function mbMimeEncodeProvider(): array
{
return [
// 0: input string
// 1: encoding
// 2: expected
'standard UTF-8' => [
'Test string',
'UTF-8',
'Test string'
],
'long text UTF-8' => [
'The quick brown fox jumps over the lazy sheep that sleeps in the ravine '
. 'and has no idea what is going on here',
'UTF-8',
'The quick brown fox jumps over the lazy sheep that sleeps in the ravine '
. 'and has no idea what is going on here'
],
'standard with special chars UTF-8' => [
'This is ümläßtと漢字もカタカナ！!^$%&',
'UTF-8',
'This is =?UTF-8?B?w7xtbMOkw59044Go5ryi5a2X44KC44Kr44K/44Kr44OK77yBIV4k?='
. "\r\n"
. ' =?UTF-8?B?JQ==?=&'
],
'35 chars and space at the end UTF-8' => [
'12345678901234567890123456789012345 '
. 'is there a space?',
'UTF-8',
'12345678901234567890123456789012345 '
. 'is there a =?UTF-8?B?c3BhY2U/?='
],
'36 chars and space at the end UTF-8' => [
'123456789012345678901234567890123456 '
. 'is there a space?',
'UTF-8',
'123456789012345678901234567890123456 '
. 'is there a =?UTF-8?B?c3BhY2U/?='
],
'36 kanji and space UTF-8' => [
'カタカナカタカナかなカタカナカタカナかなカタカナカタカナかなカタカナカタ '
. 'is there a space?',
'UTF-8',
"=?UTF-8?B?44Kr44K/44Kr44OK44Kr44K/44Kr44OK44GL44Gq44Kr44K/44Kr44OK44Kr?=\r\n"
. " =?UTF-8?B?44K/44Kr44OK?=\r\n"
. " =?UTF-8?B?44GL44Gq44Kr44K/44Kr44OK44Kr44K/44Kr44OK44GL44Gq44Kr44K/44Kr?=\r\n"
. " =?UTF-8?B?44OK44Kr44K/?= is there a =?UTF-8?B?c3BhY2U/?="
]
];
}
/**
* mb mime header encoding test
*
* @covers ::__mbMimeEncode
* @dataProvider mbMimeEncodeProvider
* @testdox mb encoding target $encoding [$_dataName]
*
* @return void
*/
public function testUuMbMimeEncode(string $input, string $encoding, string $expected): void
{
// encode string first
$encoded = \CoreLibs\Convert\MimeEncode::__mbMimeEncode($input, $encoding);
// print "MIME: -" . $encoded . "-\n";
$this->assertEquals(
$expected,
$encoded
);
$decoded = mb_decode_mimeheader($encoded);
// print "INPUT : " . $input . "\n";
// print "DECODED: " . $decoded . "\n";
// back compare decoded
$this->assertEquals(
$input,
$decoded
);
}
}
// __END__

652
4dev/tests/Convert/CoreLibsConvertSetVarTypeNullTest.php Normal file
View File

@@ -0,0 +1,652 @@
<?php // phpcs:disable Generic.Files.LineLength
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
use CoreLibs\Convert\SetVarTypeNull;
/**
* Test class for Convert\Strings
* @coversDefaultClass \CoreLibs\Convert\SetVarTypeNull
* @testdox \CoreLibs\Convert\SetVarTypeNull method tests
*/
final class CoreLibsConvertSetVarTypeNullTest extends TestCase
{
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeStringProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'empty string' => [
'',
null,
''
],
'filled string' => [
'string',
null,
'string'
],
'valid string, override set' => [
'string',
'override',
'string'
],
'int, no override' => [
1,
null,
null
],
'int, override set' => [
1,
'not int',
'not int'
]
];
}
/**
* Undocumented function
* @covers ::setStr
* @dataProvider varSetTypeStringProvider
* @testdox setStr $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param string|null $default
* @param string|null $expected
* @return void
*/
public function testSetString(mixed $input, ?string $default, ?string $expected): void
{
$set_var = SetVarTypeNull::setStr($input, $default);
if ($expected !== null) {
$this->assertIsString($set_var);
} else {
$this->assertNull($set_var);
}
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varMakeTypeStringProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'empty string' => [
'',
null,
''
],
'filled string' => [
'string',
null,
'string'
],
'valid string, override set' => [
'string',
'override',
'string'
],
'int, no override' => [
1,
null,
'1'
],
'int, override set' => [
1,
'not int',
'1'
],
'float, no override' => [
1.5,
null,
'1.5'
],
// all the strange things here
'function, override set' => [
$foo = function () {
return '';
},
'function',
'function'
],
'function, no override' => [
$foo = function () {
return '';
},
null,
null
],
'hex value, override set' => [
0x55,
'hex',
'85'
]
];
}
/**
* Undocumented function
* @covers ::makeStr
* @dataProvider varMakeTypeStringProvider
* @testdox makeStr $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param string|null $default
* @param string|null $expected
* @return void
*/
public function testMakeString(mixed $input, ?string $default, ?string $expected): void
{
$set_var = SetVarTypeNull::makeStr($input, $default);
if ($expected !== null) {
$this->assertIsString($set_var);
} else {
$this->assertNull($set_var);
}
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeIntProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'int' => [
1,
null,
1
],
'int, override set' => [
1,
-1,
1
],
'string, no override' => [
'string',
null,
null
],
'string, override' => [
'string',
-1,
-1
],
'float' => [
1.5,
null,
null
]
];
}
/**
* Undocumented function
* @covers ::setInt
* @dataProvider varSetTypeIntProvider
* @testdox setInt $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param int|null $default
* @param int|null $expected
* @return void
*/
public function testSetInt(mixed $input, ?int $default, ?int $expected): void
{
$set_var = SetVarTypeNull::setInt($input, $default);
if ($expected !== null) {
$this->assertIsInt($set_var);
} else {
$this->assertNull($set_var);
}
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varMakeTypeIntProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'int' => [
1,
null,
1
],
'int, override set' => [
1,
-1,
1
],
'string, no override' => [
'string',
null,
0
],
'string, override' => [
'string',
-1,
0
],
'float' => [
1.5,
null,
1
],
// all the strange things here
'function, override set' => [
$foo = function () {
return '';
},
-1,
-1
],
'function, no override ' => [
$foo = function () {
return '';
},
null,
null
],
'hex value, override set' => [
0x55,
-1,
85
],
];
}
/**
* Undocumented function
* @covers ::makeInt
* @dataProvider varMakeTypeIntProvider
* @testdox makeInt $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param int|null $default
* @param int|null $expected
* @return void
*/
public function testMakeInt(mixed $input, ?int $default, ?int $expected): void
{
$set_var = SetVarTypeNull::makeInt($input, $default);
if ($expected !== null) {
$this->assertIsInt($set_var);
} else {
$this->assertNull($set_var);
}
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeFloatProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'float' => [
1.5,
null,
1.5
],
'float, override set' => [
1.5,
-1.5,
1.5
],
'string, no override' => [
'string',
null,
null
],
'string, override' => [
'string',
1.5,
1.5
],
'int' => [
1,
null,
null
]
];
}
/**
* Undocumented function
* @covers ::setFloat
* @dataProvider varSetTypeFloatProvider
* @testdox setFloat $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param float|null $default
* @param float|null $expected
* @return void
*/
public function testSetFloat(mixed $input, ?float $default, ?float $expected): void
{
$set_var = SetVarTypeNull::setFloat($input, $default);
if ($expected !== null) {
$this->assertIsFloat($set_var);
} else {
$this->assertNull($set_var);
}
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varMakeTypeFloatProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'float' => [
1.5,
null,
1.5
],
'float, override set' => [
1.5,
-1.5,
1.5
],
'string, no override' => [
'string',
null,
0.0
],
'string, override' => [
'string',
1.5,
0.0
],
'int' => [
1,
null,
1.0
],
// all the strange things here
'function, override set' => [
$foo = function () {
return '';
},
-1.0,
-1.0
],
// all the strange things here
'function, no override' => [
$foo = function () {
return '';
},
null,
null
],
'hex value, override set' => [
0x55,
-1,
85.0
],
];
}
/**
* Undocumented function
* @covers ::makeFloat
* @dataProvider varMakeTypeFloatProvider
* @testdox makeFloat $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param float|null $default
* @param float|null $expected
* @return void
*/
public function testMakeFloat(mixed $input, ?float $default, ?float $expected): void
{
$set_var = SetVarTypeNull::makeFloat($input, $default);
if ($expected !== null) {
$this->assertIsFloat($set_var);
} else {
$this->assertNull($set_var);
}
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeArrayProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'array, empty' => [
[],
null,
[]
],
'array, filled' => [
['array'],
null,
['array']
],
'string, no override' => [
'string',
null,
null
],
'string, override' => [
'string',
['string'],
['string']
]
];
}
/**
* Undocumented function
* @covers ::setArray
* @dataProvider varSetTypeArrayProvider
* @testdox setArray $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param array|null $default
* @param array|null $expected
* @return void
*/
public function testSetArray(mixed $input, ?array $default, ?array $expected): void
{
$set_var = SetVarTypeNull::setArray($input, $default);
if ($expected !== null) {
$this->assertIsArray($set_var);
} else {
$this->assertNull($set_var);
}
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeBoolProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'bool true' => [
true,
null,
true
],
'bool false' => [
false,
null,
false
],
'string, no override' => [
'string',
null,
null
],
'string, override' => [
'string',
true,
true
]
];
}
/**
* Undocumented function
* @covers ::setBool
* @dataProvider varSetTypeBoolProvider
* @testdox setBool $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param bool|null $default
* @param bool|null $expected
* @return void
*/
public function testSetBool(mixed $input, ?bool $default, ?bool $expected): void
{
$set_var = SetVarTypeNull::setBool($input, $default);
if ($expected !== null) {
$this->assertIsBool($set_var);
} else {
$this->assertNull($set_var);
}
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varMakeTypeBoolProvider(): array
{
// 0: input
// 2: expected
return [
'true' => [
true,
true
],
'false' => [
false,
false
],
'string on' => [
'on',
true
],
'string off' => [
'off',
false
],
'invalid string' => [
'sulzenbacher',
null,
],
'invalid string, override' => [
'sulzenbacher',
null,
],
'array to default' => [
[],
false
],
];
}
/**
* Undocumented function
* @covers ::setBool
* @dataProvider varMakeTypeBoolProvider
* @testdox setBool $input will be $expected [$_dataName]
*
* @param mixed $input
* @param bool|null $default
* @param bool|null $expected
* @return void
*/
public function testMakeBool(mixed $input, ?bool $expected): void
{
$set_var = SetVarTypeNull::makeBool($input);
if ($expected !== null) {
$this->assertIsBool($set_var);
} else {
$this->assertNull($set_var);
}
$this->assertEquals(
$expected,
$set_var
);
}
}
// __END__

632
4dev/tests/Convert/CoreLibsConvertSetVarTypeTest.php Normal file
View File

@@ -0,0 +1,632 @@
<?php // phpcs:disable Generic.Files.LineLength
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
use CoreLibs\Convert\SetVarType;
/**
* Test class for Convert\Strings
* @coversDefaultClass \CoreLibs\Convert\SetVarType
* @testdox \CoreLibs\Convert\SetVarType method tests
*/
final class CoreLibsConvertSetVarTypeTest extends TestCase
{
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeStringProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'empty string' => [
'',
null,
''
],
'filled string' => [
'string',
null,
'string'
],
'valid string, override set' => [
'string',
'override',
'string'
],
'int, no override' => [
1,
null,
''
],
'int, override set' => [
1,
'not int',
'not int'
]
];
}
/**
* Undocumented function
* @covers ::setStr
* @dataProvider varSetTypeStringProvider
* @testdox setStr $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param string|null $default
* @param string $expected
* @return void
*/
public function testSetString(mixed $input, ?string $default, string $expected): void
{
if ($default === null) {
$set_var = SetVarType::setStr($input);
} else {
$set_var = SetVarType::setStr($input, $default);
}
$this->assertIsString($set_var);
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varMakeTypeStringProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'empty string' => [
'',
null,
''
],
'filled string' => [
'string',
null,
'string'
],
'valid string, override set' => [
'string',
'override',
'string'
],
'int, no override' => [
1,
null,
'1'
],
'int, override set' => [
1,
'not int',
'1'
],
// all the strange things here
'function, override set' => [
$foo = function () {
return '';
},
'function',
'function'
],
'hex value, override set' => [
0x55,
'hex',
'85'
]
];
}
/**
* Undocumented function
* @covers ::makeStr
* @dataProvider varMakeTypeStringProvider
* @testdox makeStr $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param string|null $default
* @param string $expected
* @return void
*/
public function testMakeString(mixed $input, ?string $default, string $expected): void
{
if ($default === null) {
$set_var = SetVarType::makeStr($input);
} else {
$set_var = SetVarType::makeStr($input, $default);
}
$this->assertIsString($set_var);
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeIntProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'int' => [
1,
null,
1
],
'int, override set' => [
1,
-1,
1
],
'string, no override' => [
'string',
null,
0
],
'string, override' => [
'string',
-1,
-1
],
'float' => [
1.5,
null,
0
]
];
}
/**
* Undocumented function
* @covers ::setInt
* @dataProvider varSetTypeIntProvider
* @testdox setInt $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param int|null $default
* @param int $expected
* @return void
*/
public function testSetInt(mixed $input, ?int $default, int $expected): void
{
if ($default === null) {
$set_var = SetVarType::setInt($input);
} else {
$set_var = SetVarType::setInt($input, $default);
}
$this->assertIsInt($set_var);
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varMakeTypeIntProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'int' => [
1,
null,
1
],
'int, override set' => [
1,
-1,
1
],
'string, no override' => [
'string',
null,
0
],
'string, override' => [
'string',
-1,
0
],
'float' => [
1.5,
null,
1
],
// all the strange things here
'function, override set' => [
$foo = function () {
return '';
},
-1,
-1
],
'hex value, override set' => [
0x55,
-1,
85
],
];
}
/**
* Undocumented function
* @covers ::makeInt
* @dataProvider varMakeTypeIntProvider
* @testdox makeInt $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param int|null $default
* @param int $expected
* @return void
*/
public function testMakeInt(mixed $input, ?int $default, int $expected): void
{
if ($default === null) {
$set_var = SetVarType::makeInt($input);
} else {
$set_var = SetVarType::makeInt($input, $default);
}
$this->assertIsInt($set_var);
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeFloatProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'float' => [
1.5,
null,
1.5
],
'float, override set' => [
1.5,
-1.5,
1.5
],
'string, no override' => [
'string',
null,
0.0
],
'string, override' => [
'string',
1.5,
1.5
],
'int' => [
1,
null,
0.0
]
];
}
/**
* Undocumented function
* @covers ::setFloat
* @dataProvider varSetTypeFloatProvider
* @testdox setFloat $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param float|null $default
* @param float $expected
* @return void
*/
public function testSetFloat(mixed $input, ?float $default, float $expected): void
{
if ($default === null) {
$set_var = SetVarType::setFloat($input);
} else {
$set_var = SetVarType::setFloat($input, $default);
}
$this->assertIsFloat($set_var);
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varMakeTypeFloatProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'float' => [
1.5,
null,
1.5
],
'float, override set' => [
1.5,
-1.5,
1.5
],
'string, no override' => [
'string',
null,
0.0
],
'string, override' => [
'string',
1.5,
0.0
],
'int' => [
1,
null,
1.0
],
// all the strange things here
'function, override set' => [
$foo = function () {
return '';
},
-1.0,
-1.0
],
'hex value, override set' => [
0x55,
-1,
85.0
],
];
}
/**
* Undocumented function
* @covers ::makeFloat
* @dataProvider varMakeTypeFloatProvider
* @testdox makeFloat $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param float|null $default
* @param float $expected
* @return void
*/
public function testMakeFloat(mixed $input, ?float $default, float $expected): void
{
if ($default === null) {
$set_var = SetVarType::makeFloat($input);
} else {
$set_var = SetVarType::makeFloat($input, $default);
}
$this->assertIsFloat($set_var);
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeArrayProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'array, empty' => [
[],
null,
[]
],
'array, filled' => [
['array'],
null,
['array']
],
'string, no override' => [
'string',
null,
[]
],
'string, override' => [
'string',
['string'],
['string']
]
];
}
/**
* Undocumented function
* @covers ::setArray
* @dataProvider varSetTypeArrayProvider
* @testdox setArray $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param array|null $default
* @param array $expected
* @return void
*/
public function testSetArray(mixed $input, ?array $default, array $expected): void
{
if ($default === null) {
$set_var = SetVarType::setArray($input);
} else {
$set_var = SetVarType::setArray($input, $default);
}
$this->assertIsArray($set_var);
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varSetTypeBoolProvider(): array
{
// 0: input
// 1: default (null default)
// 2: expected
return [
'bool true' => [
true,
null,
true
],
'bool false' => [
false,
null,
false
],
'string, no override' => [
'string',
null,
false
],
'string, override' => [
'string',
true,
true
]
];
}
/**
* Undocumented function
* @covers ::setBool
* @dataProvider varSetTypeBoolProvider
* @testdox setBool $input with override $default will be $expected [$_dataName]
*
* @param mixed $input
* @param bool|null $default
* @param bool $expected
* @return void
*/
public function testSetBool(mixed $input, ?bool $default, bool $expected): void
{
if ($default === null) {
$set_var = SetVarType::setBool($input);
} else {
$set_var = SetVarType::setBool($input, $default);
}
$this->assertIsBool($set_var);
$this->assertEquals(
$expected,
$set_var
);
}
/**
* Undocumented function
*
* @return array
*/
public function varMakeTypeBoolProvider(): array
{
// 0: input
// 2: expected
return [
'true' => [
true,
null,
true
],
'false' => [
false,
null,
false
],
'string on' => [
'on',
null,
true
],
'string off' => [
'off',
null,
false
],
'invalid string' => [
'sulzenbacher',
null,
false,
],
'invalid string, override' => [
'sulzenbacher',
true,
true,
],
'array to default' => [
[],
null,
false
],
];
}
/**
* Undocumented function
* @covers ::setBool
* @dataProvider varMakeTypeBoolProvider
* @testdox setBool $input will be $expected [$_dataName]
*
* @param mixed $input
* @param bool|null $default
* @param bool $expected
* @return void
*/
public function testMakeBool(mixed $input, ?bool $default, bool $expected): void
{
if ($default === null) {
$set_var = SetVarType::makeBool($input);
} else {
$set_var = SetVarType::makeBool($input, $default);
}
$this->assertIsBool($set_var);
$this->assertEquals(
$expected,
$set_var
);
}
}
// __END__

261
4dev/tests/Convert/CoreLibsConvertStringsTest.php Normal file
View File

@@ -0,0 +1,261 @@
<?php // phpcs:disable Generic.Files.LineLength
declare(strict_types=1);
namespace tests;
use PHPUnit\Framework\TestCase;
/**
* Test class for Convert\Strings
* @coversDefaultClass \CoreLibs\Convert\Strings
* @testdox \CoreLibs\Convert\Strings method tests
*/
final class CoreLibsConvertStringsTest extends TestCase
{
/**
* Undocumented function
*
* @return array
*/
public function splitFormatStringProvider(): array
{
// 0: input
// 1: format
// 2: split characters as string, null for default
// 3: expected
return [
'all empty string' => [
'',
'',
null,
''
],
'empty input string' => [
'',
'2-2',
null,
''
],
'empty format string string' => [
'1234',
'',
null,
'1234'
],
'string format match' => [
'1234',
'2-2',
null,
'12-34'
],
'string format trailing match' => [
'1234',
'2-2-',
null,
'12-34'
],
'string format leading match' => [
'1234',
'-2-2',
null,
'12-34'
],
'string format double inside match' => [
'1234',
'2--2',
null,
'12--34',
],
'string format short first' => [
'1',
'2-2',
null,
'1'
],
'string format match first' => [
'12',
'2-2',
null,
'12'
],
'string format short second' => [
'123',
'2-2',
null,
'12-3'
],
'string format too long' => [
'1234567',
'2-2',
null,
'12-34-567'
],
'string format invalid format string' => [
'1234',
'2_2',
null,
'1234'
],
'different split character' => [
'1234',
'2_2',
'_',
'12_34'
],
'mixed split characters' => [
'123456',
'2-2_2',
'-_',
'12-34_56'
],
'length mixed' => [
'ABCD12345568ABC13',
'2-4_5-2#4',
'-_#',
'AB-CD12_34556-8A#BC13'
],
'split with split chars in string' => [
'12-34',
'2-2',
null,
'12--3-4'
],
'mutltibyte string' => [
'あいうえ',
'2-2',
null,
'あいうえ'
],
'mutltibyte split string' => [
'1234',
'２-２',
null,
'1234'
],
];
}
/**
* split format string
*
* @covers ::splitFormatString
* @dataProvider splitFormatStringProvider
* @testdox splitFormatString $input with format $format and splitters $split_characters will be $expected [$_dataName]
*
* @param string $input
* @param string $format
* @param string|null $split_characters
* @param string $expected
* @return void
*/
public function testSplitFormatString(
string $input,
string $format,
?string $split_characters,
string $expected
): void {
if ($split_characters === null) {
$output = \CoreLibs\Convert\Strings::splitFormatString(
$input,
$format
);
} else {
$output = \CoreLibs\Convert\Strings::splitFormatString(
$input,
$format,
$split_characters
);
}
$this->assertEquals(
$expected,
$output
);
}
/**
* Undocumented function
*
* @return array
*/
public function countSplitPartsProvider(): array
{
return [
'0 elements' => [
'',
null,
0
],
'1 element' => [
'1',
null,
1,
],
'2 elements, trailing' => [
'1-2-',
null,
2
],
'2 elements, leading' => [
'-1-2',
null,
2
],
'2 elements, midde double' => [
'1--2',
null,
2
],
'4 elements' => [
'1-2-3-4',
null,
4
],
'3 elemenst, other splitter' => [
'2-3_3',
'-_',
3
],
'illegal splitter' => [
'あsdf',
null,
0
]
];
}
/**
* count split parts
*
* @covers ::countSplitParts
* @dataProvider countSplitPartsProvider
* @testdox countSplitParts $input with splitters $split_characters will be $expected [$_dataName]
*
* @param string $input
* @param string|null $split_characters
* @param int $expected
* @return void
*/
public function testCountSplitParts(
string $input,
?string $split_characters,
int $expected
): void {
if ($split_characters === null) {
$output = \CoreLibs\Convert\Strings::countSplitParts(
$input
);
} else {
$output = \CoreLibs\Convert\Strings::countSplitParts(
$input,
$split_characters
);
}
$this->assertEquals(
$expected,
$output
);
}
}
// __END__