BaseType::isCorrectType() method > make static

src/Traits/Test/Base/BaseTestCaseTrait.php

@@ -187,7 +187,7 @@ trait BaseTestCaseTrait
         int $requiredArgumentsCount = 0
     ): void {
         // Type of visibility is not correct?
-        if (!(new OopVisibilityType())->isCorrectType($visibilityType)) {
+        if (!OopVisibilityType::isCorrectType($visibilityType)) {
             throw UnknownOopVisibilityTypeException::createException($visibilityType);
         }
 

src/Traits/Test/Base/BaseTypeTestCaseTrait.php

@@ -33,14 +33,14 @@ trait BaseTypeTestCaseTrait
     /**
      * Verifies whether given type is correct or not
      *
-     * @param null|string $type     Type to verify
+     * @param bool $isCorrect Information if processed type is correct
-     * @param bool        $expected Information if given type is correct or not
+     * @param bool $expected  Expected information if processed type is correct
      *
      * @dataProvider provideTypeToVerify
      */
-    public function testIfGivenTypeIsCorrect(?string $type, bool $expected): void
+    public function testIfGivenTypeIsCorrect(bool $isCorrect, bool $expected): void
     {
-        static::assertEquals($expected, $this->getTestedTypeInstance()->isCorrectType($type));
+        static::assertEquals($expected, $isCorrect);
     }
 
     /**

src/Type/Base/BaseType.php

@@ -26,6 +26,17 @@ abstract class BaseType
      */
     private $all;
 
+    /**
+     * Returns information if given type is correct
+     *
+     * @param null|string $type The type to check
+     * @return bool
+     */
+    public static function isCorrectType(?string $type): bool
+    {
+        return in_array($type, (new static())->getAll(), true);
+    }
+
     /**
      * Returns all types
      *
@@ -39,15 +50,4 @@ abstract class BaseType
 
         return $this->all;
     }
-
-    /**
-     * Returns information if given type is correct
-     *
-     * @param null|string $type The type to check
-     * @return bool
-     */
-    public function isCorrectType(?string $type): bool
-    {
-        return in_array($type, $this->getAll(), true);
-    }
 }

src/Utilities/Date.php

@@ -76,7 +76,7 @@ class Date
          * Type of period is incorrect?
          * Nothing to do
          */
-        if (!(new DatePeriod())->isCorrectType($period)) {
+        if (!DatePeriod::isCorrectType($period)) {
             return null;
         }
 

tests/Exception/Base/UnknownTypeExceptionTest.php

@@ -94,7 +94,7 @@ class TestService
      */
     public function getTranslatedType($type)
     {
-        if ((new TestType())->isCorrectType($type)) {
+        if (TestType::isCorrectType($type)) {
             return ucfirst(str_replace('_', ' ', $type));
         }
 

tests/Type/Base/BaseTypeTest.php

@@ -41,15 +41,25 @@ class BaseTypeTest extends BaseTestCase
     }
 
     /**
-     * @param BaseType $type         Type of something
+     * @param string $toVerifyType Concrete type to verify
-     * @param string   $toVerifyType Concrete type to verify (of given instance of type)
+     * @param bool   $isCorrect    Expected information if given type is correct
-     * @param bool     $isCorrect    Expected information if given type is correct
      *
-     * @dataProvider provideTypeWithConcreteType
+     * @dataProvider provideTypeToVerifyUsingTestEmptyType
      */
-    public function testIsCorrectType(BaseType $type, $toVerifyType, $isCorrect)
+    public function testIsCorrectTypeUsingTestEmptyType(?string $toVerifyType, bool $isCorrect): void
     {
-        self::assertEquals($isCorrect, $type->isCorrectType($toVerifyType));
+        self::assertEquals($isCorrect, TestEmptyType::isCorrectType($toVerifyType));
+    }
+
+    /**
+     * @param string $toVerifyType Concrete type to verify
+     * @param bool   $isCorrect    Expected information if given type is correct
+     *
+     * @dataProvider provideTypeToVerifyUsingTestType
+     */
+    public function testIsCorrectTypeUsingTestType(?string $toVerifyType, bool $isCorrect): void
+    {
+        self::assertEquals($isCorrect, TestType::isCorrectType($toVerifyType));
     }
 
     /**
@@ -78,107 +88,108 @@ class BaseTypeTest extends BaseTestCase
      *
      * @return Generator
      */
-    public function provideTypeWithConcreteType()
+    public function provideTypeToVerifyUsingTestEmptyType(): ?Generator
     {
         yield[
-            new TestEmptyType(),
             null,
             false,
         ];
 
         yield[
-            new TestEmptyType(),
+            'null',
-            false,
             false,
         ];
 
         yield[
-            new TestEmptyType(),
+            'false',
-            true,
+            false,
+        ];
+
+        yield[
+            'true',
             false,
         ];
 
         yield[
-            new TestEmptyType(),
             '',
             false,
         ];
 
         yield[
-            new TestEmptyType(),
+            '0',
-            0,
             false,
         ];
 
         yield[
-            new TestEmptyType(),
+            '1',
-            1,
             false,
         ];
 
         yield[
-            new TestEmptyType(),
             'lorem',
             false,
         ];
+    }
 
+    /**
+     * Provides type of something for testing the isCorrectType() method
+     *
+     * @return Generator
+     */
+    public function provideTypeToVerifyUsingTestType(): ?Generator
+    {
         yield[
-            new TestType(),
             null,
             false,
         ];
 
         yield[
-            new TestType(),
+            'null',
-            false,
             false,
         ];
 
         yield[
-            new TestType(),
+            'false',
-            true,
+            false,
+        ];
+
+        yield[
+            'true',
             false,
         ];
 
         yield[
-            new TestType(),
             '',
             false,
         ];
 
         yield[
-            new TestType(),
+            '0',
-            0,
             false,
         ];
 
         yield[
-            new TestType(),
+            '1',
-            1,
             false,
         ];
 
         yield[
-            new TestType(),
             'lorem',
             false,
         ];
 
         yield[
-            new TestType(),
             'test',
             false,
         ];
 
         yield[
-            new TestType(),
+            'test_1',
-            TestType::TEST_1,
             true,
         ];
 
         yield[
-            new TestType(),
+            'test_2',
-            TestType::TEST_2,
             true,
         ];
     }

tests/Type/DatePartTypeTest.php

@@ -30,52 +30,52 @@ class DatePartTypeTest extends BaseTypeTestCase
     public function provideTypeToVerify(): Generator
     {
         yield[
-            '',
+            DatePartType::isCorrectType(''),
             false,
         ];
 
         yield[
-            null,
+            DatePartType::isCorrectType(null),
             false,
         ];
 
         yield[
-            '0',
+            DatePartType::isCorrectType('0'),
             false,
         ];
 
         yield[
-            '1',
+            DatePartType::isCorrectType('1'),
             false,
         ];
 
         yield[
-            'day',
+            DatePartType::isCorrectType('day'),
             true,
         ];
 
         yield[
-            'hour',
+            DatePartType::isCorrectType('hour'),
             true,
         ];
 
         yield[
-            'minute',
+            DatePartType::isCorrectType('minute'),
             true,
         ];
 
         yield[
-            'month',
+            DatePartType::isCorrectType('month'),
             true,
         ];
 
         yield[
-            'second',
+            DatePartType::isCorrectType('second'),
             true,
         ];
 
         yield[
-            'year',
+            DatePartType::isCorrectType('year'),
             true,
         ];
     }

tests/Type/DatePeriodTest.php

@@ -219,27 +219,27 @@ class DatePeriodTest extends BaseTypeTestCase
     public function provideTypeToVerify(): Generator
     {
         yield[
-            '',
+            DatePeriod::isCorrectType(''),
             false,
         ];
 
         yield[
-            '-1',
+            DatePeriod::isCorrectType('-1'),
             false,
         ];
 
         yield[
-            '4',
+            DatePeriod::isCorrectType('4'),
             true,
         ];
 
         yield[
-            '3',
+            DatePeriod::isCorrectType('3'),
             true,
         ];
 
         yield[
-            '8',
+            DatePeriod::isCorrectType('8'),
             true,
         ];
     }

tests/Type/OopVisibilityTypeTest.php

@@ -30,32 +30,32 @@ class OopVisibilityTypeTest extends BaseTypeTestCase
     public function provideTypeToVerify(): Generator
     {
         yield[
-            '',
+            OopVisibilityType::isCorrectType(''),
             false,
         ];
 
         yield[
-            null,
+            OopVisibilityType::isCorrectType(null),
             false,
         ];
 
         yield[
-            '-1',
+            OopVisibilityType::isCorrectType('-1'),
             false,
         ];
 
         yield[
-            '1',
+            OopVisibilityType::isCorrectType('1'),
             true,
         ];
 
         yield[
-            '2',
+            OopVisibilityType::isCorrectType('2'),
             true,
         ];
 
         yield[
-            '3',
+            OopVisibilityType::isCorrectType('3'),
             true,
         ];
     }

tests/Utilities/DateTest.php

@@ -649,13 +649,9 @@ class DateTest extends BaseTestCase
         self::assertTrue($randomDate >= $intervalMinDate && $randomDate <= $intervalMaxDate);
     }
 
-    /**
+    public function testGetDatesForPeriodUsingEmptyString(): void
-     * @param mixed $period Empty value, e.g. ""
-     * @dataProvider provideEmptyScalarValue
-     */
-    public function testGetDatesForPeriodUsingEmptyPeriod($period): void
     {
-        self::assertNull(Date::getDatesForPeriod($period));
+        self::assertNull(Date::getDatesForPeriod(''));
     }
 
     /**