Move all tests into sub folders for a more clear structure
This commit is contained in:
Clemens Schwaighofer
329
4dev/tests/Check/CoreLibsCheckColorsTest.php
Normal file
329
4dev/tests/Check/CoreLibsCheckColorsTest.php
Normal file
@@ -0,0 +1,329 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* Test class for Check\Colors
|
||||
* @coversDefaultClass \CoreLibs\Check\Colors
|
||||
* @testdox \CoreLibs\Check\Colors method tests
|
||||
*/
|
||||
final class CoreLibsCheckColorsTest extends TestCase
|
||||
{
|
||||
public function validateColorProvider(): array
|
||||
{
|
||||
/*
|
||||
0: input color string
|
||||
1: flag (or flags to set)
|
||||
2: expected result (bool)
|
||||
*/
|
||||
return [
|
||||
// * hex
|
||||
'valid hex rgb, flag ALL (default)' => [
|
||||
'#ab12cd',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
'valid hex rgb, flag ALL' => [
|
||||
'#ab12cd',
|
||||
\CoreLibs\Check\Colors::ALL,
|
||||
true,
|
||||
],
|
||||
'valid hex rgb, flag HEX_RGB' => [
|
||||
'#ab12cd',
|
||||
\CoreLibs\Check\Colors::HEX_RGB,
|
||||
true,
|
||||
],
|
||||
'valid hex rgb, wrong flag' => [
|
||||
'#ab12cd',
|
||||
\CoreLibs\Check\Colors::RGB,
|
||||
false,
|
||||
],
|
||||
// error
|
||||
'invalid hex rgb A' => [
|
||||
'#ab12zz',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
'invalid hex rgb B' => [
|
||||
'#ZyQfo',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
// other valid hex checks
|
||||
'valid hex rgb, alt A' => [
|
||||
'#AB12cd',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
// * hax alpha
|
||||
'valid hex rgb alpha, flag ALL (default)' => [
|
||||
'#ab12cd12',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
'valid hex rgb alpha, flag ALL' => [
|
||||
'#ab12cd12',
|
||||
\CoreLibs\Check\Colors::ALL,
|
||||
true,
|
||||
],
|
||||
'valid hex rgb alpha, flag HEX_RGBA' => [
|
||||
'#ab12cd12',
|
||||
\CoreLibs\Check\Colors::HEX_RGBA,
|
||||
true,
|
||||
],
|
||||
'valid hex rgb alpha, wrong flag' => [
|
||||
'#ab12cd12',
|
||||
\CoreLibs\Check\Colors::RGB,
|
||||
false,
|
||||
],
|
||||
// error
|
||||
'invalid hex rgb alpha A' => [
|
||||
'#ab12dd1',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
'invalid hex rgb alpha B' => [
|
||||
'#ab12ddzz',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
'valid hex rgb alpha, alt A' => [
|
||||
'#ab12cdEE',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
// * rgb
|
||||
'valid rgb, flag ALL (default)' => [
|
||||
'rgb(255, 10, 20)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
'valid rgb, flag ALL' => [
|
||||
'rgb(255, 10, 20)',
|
||||
\CoreLibs\Check\Colors::ALL,
|
||||
true,
|
||||
],
|
||||
'valid rgb, flag RGB' => [
|
||||
'rgb(255, 10, 20)',
|
||||
\CoreLibs\Check\Colors::RGB,
|
||||
true,
|
||||
],
|
||||
'valid rgb, wrong flag' => [
|
||||
'rgb(255, 10, 20)',
|
||||
\CoreLibs\Check\Colors::HEX_RGB,
|
||||
false,
|
||||
],
|
||||
// error
|
||||
'invalid rgb A' => [
|
||||
'rgb(356, 10, 20)',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
// other valid rgb conbinations
|
||||
'valid rgb, alt A (percent)' => [
|
||||
'rgb(100%, 10%, 20%)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
// TODO check all % and non percent combinations
|
||||
'valid rgb, alt B (percent, mix)' => [
|
||||
'rgb(100%, 10, 40)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
// * rgb alpha
|
||||
'valid rgba, flag ALL (default)' => [
|
||||
'rgba(255, 10, 20, 0.5)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
'valid rgba, flag ALL' => [
|
||||
'rgba(255, 10, 20, 0.5)',
|
||||
\CoreLibs\Check\Colors::ALL,
|
||||
true,
|
||||
],
|
||||
'valid rgba, flag RGB' => [
|
||||
'rgba(255, 10, 20, 0.5)',
|
||||
\CoreLibs\Check\Colors::RGBA,
|
||||
true,
|
||||
],
|
||||
'valid rgba, wrong flag' => [
|
||||
'rgba(255, 10, 20, 0.5)',
|
||||
\CoreLibs\Check\Colors::HEX_RGB,
|
||||
false,
|
||||
],
|
||||
// error
|
||||
'invalid rgba A' => [
|
||||
'rgba(356, 10, 20, 0.5)',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
// other valid rgba combinations
|
||||
'valid rgba, alt A (percent)' => [
|
||||
'rgba(100%, 10%, 20%, 0.5)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
// TODO check all % and non percent combinations
|
||||
'valid rgba, alt B (percent, mix)' => [
|
||||
'rgba(100%, 10, 40, 0.5)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
// TODO check all % and non percent combinations with percent transparent
|
||||
'valid rgba, alt C (percent transparent)' => [
|
||||
'rgba(100%, 10%, 20%, 50%)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
/*
|
||||
// hsl
|
||||
'hsl(100, 50%, 60%)',
|
||||
'hsl(100, 50.5%, 60.5%)',
|
||||
'hsla(100, 50%, 60%)',
|
||||
'hsla(100, 50.5%, 60.5%)',
|
||||
'hsla(100, 50%, 60%, 0.5)',
|
||||
'hsla(100, 50.5%, 60.5%, 0.5)',
|
||||
'hsla(100, 50%, 60%, 50%)',
|
||||
'hsla(100, 50.5%, 60.5%, 50%)',
|
||||
*/
|
||||
// * hsl
|
||||
'valid hsl, flag ALL (default)' => [
|
||||
'hsl(100, 50%, 60%)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
'valid hsl, flag ALL' => [
|
||||
'hsl(100, 50%, 60%)',
|
||||
\CoreLibs\Check\Colors::ALL,
|
||||
true,
|
||||
],
|
||||
'valid hsl, flag RGB' => [
|
||||
'hsl(100, 50%, 60%)',
|
||||
\CoreLibs\Check\Colors::HSL,
|
||||
true,
|
||||
],
|
||||
'valid hsl, wrong flag' => [
|
||||
'hsl(100, 50%, 60%)',
|
||||
\CoreLibs\Check\Colors::HEX_RGB,
|
||||
false,
|
||||
],
|
||||
'invalid hsl A' => [
|
||||
'hsl(500, 50%, 60%)',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
'valid hsl, alt A' => [
|
||||
'hsl(100, 50.5%, 60.5%)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
// * hsl alpha
|
||||
'valid hsla, flag ALL (default)' => [
|
||||
'hsla(100, 50%, 60%, 0.5)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
'valid hsla, flag ALL' => [
|
||||
'hsla(100, 50%, 60%, 0.5)',
|
||||
\CoreLibs\Check\Colors::ALL,
|
||||
true,
|
||||
],
|
||||
'valid hsla, flag RGB' => [
|
||||
'hsla(100, 50%, 60%, 0.5)',
|
||||
\CoreLibs\Check\Colors::HSLA,
|
||||
true,
|
||||
],
|
||||
'valid hsla, wrong flag' => [
|
||||
'hsla(100, 50%, 60%, 0.5)',
|
||||
\CoreLibs\Check\Colors::HEX_RGB,
|
||||
false,
|
||||
],
|
||||
'invalid hsla A' => [
|
||||
'hsla(500, 50%, 60%, 0.5)',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
'valid hsla, alt A (percent alpha' => [
|
||||
'hsla(100, 50%, 60%, 50%)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
'valid hsla, alt A (percent alpha' => [
|
||||
'hsla(100, 50.5%, 60.5%, 50%)',
|
||||
null,
|
||||
true,
|
||||
],
|
||||
// * combined flag checks
|
||||
'valid rgb, flag RGB|RGBA' => [
|
||||
'rgb(100%, 10%, 20%)',
|
||||
\CoreLibs\Check\Colors::RGB | \CoreLibs\Check\Colors::RGBA,
|
||||
true,
|
||||
],
|
||||
// TODO other combined flag checks all combinations
|
||||
// * invalid string
|
||||
'invalid string A' => [
|
||||
'invalid string',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
'invalid string B' => [
|
||||
'(hsla(100, 100, 100))',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
'invalid string C' => [
|
||||
'hsla(100, 100, 100',
|
||||
null,
|
||||
false,
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::validateColor
|
||||
* @dataProvider validateColorProvider
|
||||
* @testdox validateColor $input with flags $flags be $expected [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param int|null $flags
|
||||
* @param bool $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testValidateColor(string $input, ?int $flags, bool $expected)
|
||||
{
|
||||
if ($flags === null) {
|
||||
$result = \CoreLibs\Check\Colors::validateColor($input);
|
||||
} else {
|
||||
$result = \CoreLibs\Check\Colors::validateColor($input, $flags);
|
||||
}
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
$result
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::validateColor
|
||||
* @testWith [99]
|
||||
* @testdox Check Exception throw for $flag
|
||||
*
|
||||
* @param int $flag
|
||||
* @return void
|
||||
*/
|
||||
public function testValidateColorException(int $flag): void
|
||||
{
|
||||
$this->expectException(\Exception::class);
|
||||
\CoreLibs\Check\Colors::validateColor('#ffffff', $flag);
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
381
4dev/tests/Check/CoreLibsCheckEmailTest.php
Normal file
381
4dev/tests/Check/CoreLibsCheckEmailTest.php
Normal file
@@ -0,0 +1,381 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* Undocumented class
|
||||
* @coversDefaultClass \CoreLibs\Check\Email
|
||||
* @testdox \CoreLibs\Check\Email method tests
|
||||
*/
|
||||
final class CoreLibsCheckEmailTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* Array position to regex
|
||||
*
|
||||
* @return array<mixed>
|
||||
*/
|
||||
public function emailRegexProvider(): array
|
||||
{
|
||||
return [
|
||||
'get email regex invalid -1, will be 0' => [
|
||||
-1,
|
||||
"^[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}@"
|
||||
. "[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]{1,})*\.([a-zA-Z]{2,}){1}$"
|
||||
],
|
||||
'get email regex invalid 10, will be 0' => [
|
||||
10,
|
||||
"^[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}@"
|
||||
. "[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]{1,})*\.([a-zA-Z]{2,}){1}$"
|
||||
],
|
||||
'get email regex valid 1, will be 1' => [
|
||||
1,
|
||||
"@(.*)@(.*)"
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Test regex level return
|
||||
*
|
||||
* @covers ::getEmailRegex
|
||||
* @dataProvider emailRegexProvider
|
||||
* @testdox getEmailRegex $input will be $expected [$_dataName]
|
||||
*
|
||||
* @param int $input
|
||||
* @param string $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testGetEmailRegexReturn(int $input, string $expected): void
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Check\Email::getEmailRegex($input)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* provides data for emailCheckProvider and emailCheckFullProvider
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function emailCheckList(): array
|
||||
{
|
||||
return [
|
||||
'valid email' => ['test@test.com', true, []],
|
||||
'invalid empty email' => ['', false, [0, 2, 3, 4, 5]],
|
||||
'invalid email' => ['-@-', false, [0, 3, 4, 5]],
|
||||
'invalid email leading dot' => ['.test@test.com', false, [0, 2]],
|
||||
'invalid email invalid domain' => ['test@t_est.com', false, [0, 3, 4]],
|
||||
'invalid email double @' => ['test@@test.com', false, [0, 1]],
|
||||
'invalid email double dot' => ['test@test..com', false, [0, 3, 6]],
|
||||
'invalid email end with dot' => ['test@test.', false, [0, 3, 5, 7]],
|
||||
'invalid email bad top level' => ['test@test.j', false, [0, 3, 5]],
|
||||
'invalid email double @ and double dot' => ['test@@test..com', false, [0, 1, 3, 6]],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Valids or not valid email address
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function emailCheckProvider(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->emailCheckList() as $key => $data) {
|
||||
$list[$key] = [$data[0], $data[1]];
|
||||
}
|
||||
return $list;
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::checkEmail
|
||||
* @dataProvider emailCheckProvider
|
||||
* @testdox checkEmail $input will be $expected [$_dataName]
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function testCheckEmail(string $input, bool $expected): void
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Check\Email::checkEmail($input)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* this is like emailCheckProvider but it has the full detail errors
|
||||
* All errors should be tetsed in testGetEmailRegexErrorMessage
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function emailCheckFullProvider(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->emailCheckList() as $key => $data) {
|
||||
$list[$key] = [$data[0], $data[2]];
|
||||
}
|
||||
return $list;
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::checkEmailFull
|
||||
* @dataProvider emailCheckFullProvider
|
||||
* @testdox checkEmailFull $input will be $expected [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param array $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testCheckEmailFull(string $input, array $expected): void
|
||||
{
|
||||
$this->assertEqualsCanonicalizing(
|
||||
$expected,
|
||||
\CoreLibs\Check\Email::checkEmailFull($input, true)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* error data returned for each error position
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function emailRegexErrorProvider(): array
|
||||
{
|
||||
return [
|
||||
'error 0 will return general' => [
|
||||
0,
|
||||
[
|
||||
'error' => 0,
|
||||
'message' => 'Invalid email address',
|
||||
'regex' => "^[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}@"
|
||||
. "[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]{1,})*\.([a-zA-Z]{2,}){1}$"
|
||||
]
|
||||
],
|
||||
'error 1 will return double @ error' => [
|
||||
1,
|
||||
[
|
||||
'error' => 1,
|
||||
'message' => 'Double @ mark in email address',
|
||||
'regex' => "@(.*)@(.*)"
|
||||
]
|
||||
],
|
||||
'error 2 will be invalid before @' => [
|
||||
2,
|
||||
[
|
||||
'error' => 2,
|
||||
'message' => 'Invalid email part before @ sign',
|
||||
'regex' => "^[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}@"
|
||||
]
|
||||
],
|
||||
'error 3 will be invalid domain and top level' => [
|
||||
3,
|
||||
[
|
||||
'error' => 3,
|
||||
'message' => 'Invalid domain part after @ sign',
|
||||
'regex' => "@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]{1,})*\.([a-zA-Z]{2,}){1}$"
|
||||
]
|
||||
],
|
||||
'error 4 will be invalid domain' => [
|
||||
4,
|
||||
[
|
||||
'error' => 4,
|
||||
'message' => 'Invalid domain name part',
|
||||
'regex' => "@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]{1,})*\."
|
||||
]
|
||||
],
|
||||
'error 5 will be invalid domain top level only' => [
|
||||
5,
|
||||
[
|
||||
'error' => 5,
|
||||
'message' => 'Wrong domain top level part',
|
||||
'regex' => "\.([a-zA-Z]{2,6}){1}$"
|
||||
]
|
||||
],
|
||||
'error 6 will be domain double dot' => [
|
||||
6,
|
||||
[
|
||||
'error' => 6,
|
||||
'message' => 'Double consecutive dots in domain name (..)',
|
||||
'regex' => "@(.*)\.{2,}"
|
||||
]
|
||||
],
|
||||
'error 7 will domain ends with dot' => [
|
||||
7,
|
||||
[
|
||||
'error' => 7,
|
||||
'message' => 'Domain ends with a dot or is missing top level part',
|
||||
'regex' => "@.*\.$"
|
||||
]
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::getEmailRegexErrorMessage
|
||||
* @dataProvider emailRegexErrorProvider
|
||||
* @testdox getEmailRegexErrorMessage $input will be $expected [$_dataName]
|
||||
*
|
||||
* @param integer $input
|
||||
* @param array $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testGetEmailRegexErrorMessage(int $input, array $expected): void
|
||||
{
|
||||
$this->assertEqualsCanonicalizing(
|
||||
$expected,
|
||||
\CoreLibs\Check\Email::getEmailRegexErrorMessage($input)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* This holds all email type checks normal and short
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function emailTypeProvider(): array
|
||||
{
|
||||
return [
|
||||
['test@test.com', 'pc_html', 'pc'],
|
||||
['test@docomo.ne.jp', 'keitai_docomo', 'docomo'],
|
||||
['test@softbank.ne.jp', 'keitai_softbank', 'softbank'],
|
||||
['test@i.softbank.ne.jp', 'smartphone_softbank_iphone', 'iphone'],
|
||||
// TODO: add more test emails here
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns only normal email type checks
|
||||
*
|
||||
* @return array<mixed>
|
||||
*/
|
||||
public function emailTypeProviderLong(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->emailTypeProvider() as $set) {
|
||||
$list['email ' . $set[0] . ' is valid and matches normal ' . $set[1]] = [$set[0], $set[1]];
|
||||
}
|
||||
$list['email is empty and not valid normal'] = ['', 'invalid'];
|
||||
return $list;
|
||||
}
|
||||
|
||||
/**
|
||||
* only short email type list
|
||||
*
|
||||
* @return array<mixed>
|
||||
*/
|
||||
public function emailTypeProviderShort(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->emailTypeProvider() as $set) {
|
||||
$list['email ' . $set[0] . ' is valid and matches short ' . $set[2]] = [$set[0], $set[2]];
|
||||
}
|
||||
$list['email is empty and not valid short'] = ['', 'invalid'];
|
||||
return $list;
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::getEmailType
|
||||
* @dataProvider emailTypeProviderLong
|
||||
* @testdox getEmailType $input will be normal $expected [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param string $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testGetEmailTypeNormal(string $input, string $expected)
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Check\Email::getEmailType($input, false)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::getEmailType
|
||||
* @dataProvider emailTypeProviderShort
|
||||
* @testdox getEmailType $input will be short $expected [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param string $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testGetEmailTypeShort(string $input, string $expected)
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Check\Email::getEmailType($input, true)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function emailProviderTypeLongToShort(): array
|
||||
{
|
||||
$mobile_email_type_short = [
|
||||
'keitai_docomo' => 'docomo',
|
||||
'keitai_kddi_ezweb' => 'kddi',
|
||||
'keitai_kddi' => 'kddi',
|
||||
'keitai_kddi_tu-ka' => 'kddi',
|
||||
'keitai_kddi_sky' => 'kddi',
|
||||
'keitai_softbank' => 'softbank',
|
||||
'smartphone_softbank_iphone' => 'iphone',
|
||||
'keitai_softbank_disney' => 'softbank',
|
||||
'keitai_softbank_vodafone' => 'softbank',
|
||||
'keitai_softbank_j-phone' => 'softbank',
|
||||
'keitai_willcom' => 'willcom',
|
||||
'keitai_willcom_pdx' => 'willcom',
|
||||
'keitai_willcom_bandai' => 'willcom',
|
||||
'keitai_willcom_pipopa' => 'willcom',
|
||||
'keitai_willcom_ymobile' => 'willcom',
|
||||
'keitai_willcom_emnet' => 'willcom',
|
||||
'pc_html' => 'pc',
|
||||
];
|
||||
$list = [];
|
||||
// use the static one
|
||||
foreach ($mobile_email_type_short as $long => $short) {
|
||||
$list[$long . ' matches to ' . $short] = [$long, $short];
|
||||
}
|
||||
// add invalid check
|
||||
$list['Not found will be bool false'] = ['invalid', false];
|
||||
return $list;
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::getShortEmailType
|
||||
* @dataProvider emailProviderTypeLongToShort
|
||||
* @testdox getShortEmailType $input will be $expected [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param string|bool $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testGetShortEmailType(string $input, $expected)
|
||||
{
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Check\Email::getShortEmailType($input)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
120
4dev/tests/Check/CoreLibsCheckEncodingTest.php
Normal file
120
4dev/tests/Check/CoreLibsCheckEncodingTest.php
Normal file
@@ -0,0 +1,120 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* Test class for Check\Encoding
|
||||
* @coversDefaultClass \CoreLibs\Check\Encoding
|
||||
* @testdox \CoreLibs\Check\Encoding method tests
|
||||
*/
|
||||
final class CoreLibsCheckEncodingTest extends TestCase
|
||||
{
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function checkConvertEncodingProvider(): array
|
||||
{
|
||||
return [
|
||||
// 0: string to test
|
||||
// 1: source encoding
|
||||
// 2: target encoding
|
||||
// 3: substitue character
|
||||
// 4: false for ok, array with error list
|
||||
'valid test UTF-8 to SJIS (default)' => [
|
||||
'日本語',
|
||||
'UTF-8',
|
||||
'SJIS',
|
||||
null,
|
||||
false
|
||||
],
|
||||
'invalid test UTF-8 to SJIS (dots as code point)' => [
|
||||
'❶',
|
||||
'UTF-8',
|
||||
'SJIS',
|
||||
0x2234,
|
||||
['❶']
|
||||
],
|
||||
'invalid test UTF-8 to SJIS (dots as string)' => [
|
||||
'❶',
|
||||
'UTF-8',
|
||||
'SJIS',
|
||||
'∴',
|
||||
['❶']
|
||||
],
|
||||
'invalid test UTF-8 to SJIS (none)' => [
|
||||
'❶',
|
||||
'UTF-8',
|
||||
'SJIS',
|
||||
'none',
|
||||
['❶']
|
||||
],
|
||||
'invalid test UTF-8 to SJIS (long)' => [
|
||||
'❶',
|
||||
'UTF-8',
|
||||
'SJIS',
|
||||
'long',
|
||||
['❶']
|
||||
],
|
||||
'invalid test UTF-8 to SJIS (entity)' => [
|
||||
'❶',
|
||||
'UTF-8',
|
||||
'SJIS',
|
||||
'entity',
|
||||
['❶']
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::checkConvertEncoding
|
||||
* @dataProvider checkConvertEncodingProvider
|
||||
* @testdox check encoding convert from $from_encoding to $to_encoding [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param string $from_encoding
|
||||
* @param string $to_encoding
|
||||
* @param string|int|null $error_char
|
||||
* @param array|bool $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testCheckConvertEncoding(
|
||||
string $input,
|
||||
string $from_encoding,
|
||||
string $to_encoding,
|
||||
$error_char,
|
||||
$expected
|
||||
): void {
|
||||
$current_subsitute_character = mb_substitute_character();
|
||||
if ($error_char !== null) {
|
||||
\CoreLibs\Check\Encoding::setErrorChar($error_char);
|
||||
if (!in_array($error_char, ['none', 'long', 'entity'])) {
|
||||
$this->assertEquals(
|
||||
\IntlChar::chr($error_char),
|
||||
\CoreLibs\Check\Encoding::getErrorChar()
|
||||
);
|
||||
} else {
|
||||
$this->assertEquals(
|
||||
$error_char,
|
||||
\CoreLibs\Check\Encoding::getErrorChar()
|
||||
);
|
||||
}
|
||||
}
|
||||
$return = \CoreLibs\Check\Encoding::checkConvertEncoding($input, $from_encoding, $to_encoding);
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
$return
|
||||
);
|
||||
// reset after test
|
||||
mb_substitute_character($current_subsitute_character);
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
120
4dev/tests/Check/CoreLibsCheckFileTest.php
Normal file
120
4dev/tests/Check/CoreLibsCheckFileTest.php
Normal file
@@ -0,0 +1,120 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* Test class for Check\File
|
||||
* @coversDefaultClass \CoreLibs\Check\File
|
||||
* @testdox \CoreLibs\Check\File method tests
|
||||
*/
|
||||
final class CoreLibsCheckFileTest extends TestCase
|
||||
{
|
||||
/** @var array<mixed> */
|
||||
// private $files_list = [];
|
||||
/** @var string */
|
||||
private $base_folder = DIRECTORY_SEPARATOR . 'tmp' . DIRECTORY_SEPARATOR;
|
||||
|
||||
/**
|
||||
* main file list + data provider
|
||||
*
|
||||
* filename, file extension matching, lines in file, -1 for nothing
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function filesList(): array
|
||||
{
|
||||
return [
|
||||
['filename.txt', 'txt', 5],
|
||||
['filename.csv', 'csv', 15],
|
||||
['filename.tsv', 'tsv', 0],
|
||||
['file_does_not_exits', '', -1],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function filesExtensionProvider(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->filesList() as $row) {
|
||||
$list[$row[0] . ' must be extension ' . $row[1]] = [$row[0], $row[1]];
|
||||
}
|
||||
return $list;
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function filesLinesProvider(): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($this->filesList() as $row) {
|
||||
$list[$row[0] . ' must have ' . $row[2] . ' lines'] = [$row[0], $row[2]];
|
||||
}
|
||||
return $list;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests if file extension matches
|
||||
*
|
||||
* @covers ::getFilenameEnding
|
||||
* @dataProvider filesExtensionProvider
|
||||
* @testdox getFilenameEnding $input must be extension $expected [$_dataName]
|
||||
*
|
||||
* @param string $input
|
||||
* @param string $expected
|
||||
* @return void
|
||||
*/
|
||||
public function testGetFilenameEnding(string $input, string $expected): void
|
||||
{
|
||||
// getFilenameEnding
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Check\File::getFilenameEnding($input)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the file line read
|
||||
*
|
||||
* @covers ::getLinesFromFile
|
||||
* @dataProvider filesLinesProvider
|
||||
* @testdox getLinesFromFile $input must have $expected lines [$_dataName]
|
||||
*
|
||||
* @param string $input file name
|
||||
* @param int $expected lines in file
|
||||
* @return void
|
||||
*/
|
||||
public function testGetLinesFromFile(string $input, int $expected): void
|
||||
{
|
||||
// create file
|
||||
if ($expected > -1) {
|
||||
$file = $this->base_folder . $input;
|
||||
$fp = fopen($file, 'w');
|
||||
for ($i = 0; $i < $expected; $i++) {
|
||||
fwrite($fp, 'This is row ' . ($i + 1) . PHP_EOL);
|
||||
}
|
||||
fclose($fp);
|
||||
}
|
||||
// test
|
||||
$this->assertEquals(
|
||||
$expected,
|
||||
\CoreLibs\Check\File::getLinesFromFile($this->base_folder . $input)
|
||||
);
|
||||
// unlink file
|
||||
if (is_file($this->base_folder . $input)) {
|
||||
unlink($this->base_folder . $input);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// __END__
|
||||
73
4dev/tests/Check/CoreLibsCheckPasswordTest.php
Normal file
73
4dev/tests/Check/CoreLibsCheckPasswordTest.php
Normal file
@@ -0,0 +1,73 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* Test class for Check\Password
|
||||
* @coversDefaultClass \CoreLibs\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
|
||||
*
|
||||
* @covers ::passwordVerify
|
||||
* @covers ::passwordSet
|
||||
* @dataProvider passwordProvider
|
||||
* @testdox passwordSet $input compare to $input_hash: passwordVerify $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
|
||||
*
|
||||
* @covers ::passwordRehashCheck
|
||||
* @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__
|
||||
73
4dev/tests/Check/CoreLibsCheckPhpVersionTest.php
Normal file
73
4dev/tests/Check/CoreLibsCheckPhpVersionTest.php
Normal file
@@ -0,0 +1,73 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace tests;
|
||||
|
||||
use PHPUnit\Framework\TestCase;
|
||||
|
||||
/**
|
||||
* Test class for Check\PHPVersion
|
||||
* @coversDefaultClass \CoreLibs\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],
|
||||
// min/max version, NOTE: update if php version bigger than 10
|
||||
'min 7/max 10' => ['7', '10', true],
|
||||
'min 7/max 10.0' => ['7', '10.0', true],
|
||||
'min 7/max 10.0.0' => ['7', '10.0.0', true],
|
||||
// min/max version
|
||||
'min 5/max 7' => ['5', '7', false],
|
||||
'min 5/max 7.4' => ['5', '7.4', false],
|
||||
'min 5/max 7.4.1' => ['5', '7.4.1', false],
|
||||
// max only
|
||||
'max 7' => ['', '7', false],
|
||||
'max 7.4' => ['', '7.4', false],
|
||||
'max 7.4.1' => ['', '7.4.1', false],
|
||||
// max over
|
||||
'max 10' => ['', '10', true],
|
||||
'max 10.0' => ['', '10.0', true],
|
||||
'max 10.0.0' => ['', '10.0.0', true],
|
||||
// TODO: add null tests
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Undocumented function
|
||||
*
|
||||
* @covers ::checkPHPVersion
|
||||
* @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__
|
||||
Reference in New Issue
Block a user