Add more type tests

SerafimArts · SerafimArts · commit a2aa029abe6f · 2025-10-25T00:51:18.000+03:00
diff --git a/src/Type/Coercer/ArrayKeyTypeCoercer.php b/src/Type/Coercer/ArrayKeyTypeCoercer.php
@@ -10,7 +10,7 @@
 /**
  * @template-implements TypeCoercerInterface<array-key>
  */
-final class ArrayKeyTypeCoercer implements TypeCoercerInterface
+class ArrayKeyTypeCoercer implements TypeCoercerInterface
 {
     public function coerce(mixed $value, Context $context): int|string
     {
diff --git a/src/Type/Coercer/BoolTypeCoercer.php b/src/Type/Coercer/BoolTypeCoercer.php
@@ -9,7 +9,7 @@
 /**
  * @template-implements TypeCoercerInterface<bool>
  */
-final class BoolTypeCoercer implements TypeCoercerInterface
+class BoolTypeCoercer implements TypeCoercerInterface
 {
     public function coerce(mixed $value, Context $context): bool
     {
diff --git a/src/Type/Coercer/FloatTypeCoercer.php b/src/Type/Coercer/FloatTypeCoercer.php
@@ -10,7 +10,7 @@
 /**
  * @template-implements TypeCoercerInterface<float>
  */
-final class FloatTypeCoercer implements TypeCoercerInterface
+class FloatTypeCoercer implements TypeCoercerInterface
 {
     public function coerce(mixed $value, Context $context): float
     {
diff --git a/src/Type/Coercer/IntTypeCoercer.php b/src/Type/Coercer/IntTypeCoercer.php
@@ -10,7 +10,7 @@
 /**
  * @template-implements TypeCoercerInterface<int>
  */
-final class IntTypeCoercer implements TypeCoercerInterface
+class IntTypeCoercer implements TypeCoercerInterface
 {
     public function coerce(mixed $value, Context $context): int
     {
diff --git a/src/Type/FloatLiteralType.php b/src/Type/FloatLiteralType.php
@@ -31,16 +31,12 @@ public function __construct(
      */
     public function match(mixed $value, Context $context): bool
     {
-        if (\is_int($value)) {
-            return (float) $value === $this->value;
-        }
-
         return $value === $this->value;
     }
 
     public function cast(mixed $value, Context $context): float
     {
-        if ($this->match($value, $context)) {
+        if ($value === $this->value) {
             return (float) $value;
         }
 
diff --git a/tests/Type/ArrayKeyTypeTest.php b/tests/Type/ArrayKeyTypeTest.php
@@ -7,14 +7,19 @@
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Group;
 use TypeLang\Mapper\Type\ArrayKeyType;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
 use TypeLang\Mapper\Type\TypeInterface;
 
-#[Group('types')]
+#[Group('type')]
 #[CoversClass(ArrayKeyType::class)]
-final class ArrayKeyTypeTest extends TypeTestCase
+final class ArrayKeyTypeTest extends CoercibleTypeTestCase
 {
-    protected static function createType(): TypeInterface
+    protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface
     {
+        if ($coercer !== null) {
+            return new ArrayKeyType(coercer: $coercer);
+        }
+
         return new ArrayKeyType();
     }
 
diff --git a/tests/Type/BoolFalseLiteralTypeTest.php b/tests/Type/BoolFalseLiteralTypeTest.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Group;
+use TypeLang\Mapper\Type\BoolLiteralType;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
+use TypeLang\Mapper\Type\TypeInterface;
+
+#[Group('type')]
+#[CoversClass(BoolLiteralType::class)]
+final class BoolFalseLiteralTypeTest extends CoercibleTypeTestCase
+{
+    protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface
+    {
+        if ($coercer !== null) {
+            return new BoolLiteralType(false, coercer: $coercer);
+        }
+
+        return new BoolLiteralType(false);
+    }
+
+    protected static function matchValues(bool $normalize): iterable
+    {
+        foreach (self::defaultMatchDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                // Only false is matching
+                $value === false => true,
+                default => $default,
+            };
+        }
+    }
+
+    protected static function castValues(bool $normalize): iterable
+    {
+        foreach (self::defaultCastDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                // Only false may cast to false
+                $value === false => false,
+                default => $default,
+            };
+        }
+    }
+}
diff --git a/tests/Type/BoolTrueLiteralTypeTest.php b/tests/Type/BoolTrueLiteralTypeTest.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Group;
+use TypeLang\Mapper\Type\BoolLiteralType;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
+use TypeLang\Mapper\Type\TypeInterface;
+
+#[Group('type')]
+#[CoversClass(BoolLiteralType::class)]
+final class BoolTrueLiteralTypeTest extends CoercibleTypeTestCase
+{
+    protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface
+    {
+        if ($coercer !== null) {
+            return new BoolLiteralType(true, coercer: $coercer);
+        }
+
+        return new BoolLiteralType(true);
+    }
+
+    protected static function matchValues(bool $normalize): iterable
+    {
+        foreach (self::defaultMatchDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                // Only true is matches
+                $value === true => true,
+                default => $default,
+            };
+        }
+    }
+
+    protected static function castValues(bool $normalize): iterable
+    {
+        foreach (self::defaultCastDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                // Only true may casts
+                $value === true => true,
+                default => $default,
+            };
+        }
+    }
+}
diff --git a/tests/Type/BoolTypeTest.php b/tests/Type/BoolTypeTest.php
@@ -7,14 +7,19 @@
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Group;
 use TypeLang\Mapper\Type\BoolType;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
 use TypeLang\Mapper\Type\TypeInterface;
 
-#[Group('types')]
+#[Group('type')]
 #[CoversClass(BoolType::class)]
-final class BoolTypeTest extends TypeTestCase
+final class BoolTypeTest extends CoercibleTypeTestCase
 {
-    protected static function createType(): TypeInterface
+    protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface
     {
+        if ($coercer !== null) {
+            return new BoolType(coercer: $coercer);
+        }
+
         return new BoolType();
     }
 
diff --git a/tests/Type/CoercibleTypeTestCase.php b/tests/Type/CoercibleTypeTestCase.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Type;
+
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
+use TypeLang\Mapper\Type\TypeInterface;
+
+abstract class CoercibleTypeTestCase extends TypeTestCase
+{
+    abstract protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface;
+
+    /**
+     * @api
+     */
+    public function testUsesTypeCoercion(): void
+    {
+        $this->expectException(\BadMethodCallException::class);
+        $this->expectExceptionMessage('on-coerce');
+
+        $coercer = $this->createMock(TypeCoercerInterface::class);
+        $coercer->method('coerce')
+            ->willThrowException(new \BadMethodCallException('on-coerce'));
+
+        $value = \fopen('php://memory', 'rb');
+
+        $type = static::createType($coercer);
+        $type->cast($value, $this->createNormalizationContext($value, false));
+    }
+}
diff --git a/tests/Type/FloatLiteralTypeTest.php b/tests/Type/FloatLiteralTypeTest.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Group;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
+use TypeLang\Mapper\Type\FloatLiteralType;
+use TypeLang\Mapper\Type\TypeInterface;
+
+#[Group('type')]
+#[CoversClass(FloatLiteralType::class)]
+final class FloatLiteralTypeTest extends CoercibleTypeTestCase
+{
+    protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface
+    {
+        if ($coercer !== null) {
+            return new FloatLiteralType(42, coercer: $coercer);
+        }
+
+        return new FloatLiteralType(42);
+    }
+
+    protected static function matchValues(bool $normalize): iterable
+    {
+        foreach (self::defaultMatchDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                $value === 42.0 => true,
+                default => $default,
+            };
+        }
+    }
+
+    protected static function castValues(bool $normalize): iterable
+    {
+        foreach (self::defaultCastDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                $value === 42.0 => 42.0,
+                default => $default,
+            };
+        }
+    }
+}
diff --git a/tests/Type/FloatTypeTest.php b/tests/Type/FloatTypeTest.php
@@ -6,15 +6,20 @@
 
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Group;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
 use TypeLang\Mapper\Type\FloatType;
 use TypeLang\Mapper\Type\TypeInterface;
 
-#[Group('types')]
+#[Group('type')]
 #[CoversClass(FloatType::class)]
-final class FloatTypeTest extends TypeTestCase
+final class FloatTypeTest extends CoercibleTypeTestCase
 {
-    protected static function createType(): TypeInterface
+    protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface
     {
+        if ($coercer !== null) {
+            return new FloatType(coercer: $coercer);
+        }
+
         return new FloatType();
     }
 
diff --git a/tests/Type/IntLiteralTypeTest.php b/tests/Type/IntLiteralTypeTest.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Group;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
+use TypeLang\Mapper\Type\IntLiteralType;
+use TypeLang\Mapper\Type\TypeInterface;
+
+#[Group('type')]
+#[CoversClass(IntLiteralType::class)]
+final class IntLiteralTypeTest extends CoercibleTypeTestCase
+{
+    protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface
+    {
+        if ($coercer !== null) {
+            return new IntLiteralType(42, coercer: $coercer);
+        }
+
+        return new IntLiteralType(42);
+    }
+
+    protected static function matchValues(bool $normalize): iterable
+    {
+        foreach (self::defaultMatchDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                $value === 42 => true,
+                default => $default,
+            };
+        }
+    }
+
+    protected static function castValues(bool $normalize): iterable
+    {
+        foreach (self::defaultCastDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                $value === 42 => 42,
+                default => $default,
+            };
+        }
+    }
+}
diff --git a/tests/Type/IntRangeTypeTest.php b/tests/Type/IntRangeTypeTest.php
@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Group;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
+use TypeLang\Mapper\Type\IntRangeType;
+use TypeLang\Mapper\Type\TypeInterface;
+
+#[Group('type')]
+#[CoversClass(IntRangeType::class)]
+final class IntRangeTypeTest extends CoercibleTypeTestCase
+{
+    protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface
+    {
+        if ($coercer !== null) {
+            return new IntRangeType(-1, 1, coercer: $coercer);
+        }
+
+        return new IntRangeType(-1, 1);
+    }
+
+    protected static function matchValues(bool $normalize): iterable
+    {
+        foreach (self::defaultMatchDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                $value === 1,
+                $value === 0,
+                $value === -1 => true,
+                default => $default,
+            };
+        }
+    }
+
+    protected static function castValues(bool $normalize): iterable
+    {
+        foreach (self::defaultCastDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                $value === 1 => 1,
+                $value === 0 => 0,
+                $value === -1 => -1,
+                default => $default,
+            };
+        }
+    }
+}
diff --git a/tests/Type/IntTypeTest.php b/tests/Type/IntTypeTest.php
diff --git a/tests/Type/StringTypeTest.php b/tests/Type/StringTypeTest.php

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`/**`
`11`	`11`	`* @template-implements TypeCoercerInterface<array-key>`
`12`	`12`	`*/`
`13`		`-final class ArrayKeyTypeCoercer implements TypeCoercerInterface`
	`13`	`+class ArrayKeyTypeCoercer implements TypeCoercerInterface`
`14`	`14`	`{`
`15`	`15`	`public function coerce(mixed $value, Context $context): int\|string`
`16`	`16`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`	`/**`
`10`	`10`	`* @template-implements TypeCoercerInterface<bool>`
`11`	`11`	`*/`
`12`		`-final class BoolTypeCoercer implements TypeCoercerInterface`
	`12`	`+class BoolTypeCoercer implements TypeCoercerInterface`
`13`	`13`	`{`
`14`	`14`	`public function coerce(mixed $value, Context $context): bool`
`15`	`15`	`{`
Original file line number	Diff line number	Diff line change
`@@ -31,16 +31,12 @@ public function __construct(`
`31`	`31`	`*/`
`32`	`32`	`public function match(mixed $value, Context $context): bool`
`33`	`33`	`{`
`34`		`- if (\is_int($value)) {`
`35`		`- return (float) $value === $this->value;`
`36`		`- }`
`37`		`-`
`38`	`34`	`return $value === $this->value;`
`39`	`35`	`}`
`40`	`36`
`41`	`37`	`public function cast(mixed $value, Context $context): float`
`42`	`38`	`{`
`43`		`- if ($this->match($value, $context)) {`
	`39`	`+ if ($value === $this->value) {`
`44`	`40`	`return (float) $value;`
`45`	`41`	`}`
`46`	`42`