Add unit tests for type aliases and improve static return type usage

- Added comprehensive unit tests for new type aliases, including `Str`, `NonEmptyStr`, `StrType`, `Integer`, `PositiveInt`, `IntType`, `NonNegativeInt`, `TinyInt`, `Double`, `FloatType`, `PositiveFloat`, and `NonNegativeFloat`.
- Refactored return types from `self` to `static` in `DateTimeW3C`, `TimestampMilliseconds`, and `Json` for improved type consistency and covariant support.

Author: georgedeploy

src/DateTime/DateTimeW3C.php

@@ -28,7 +28,7 @@
     public static function fromString(string $value): static
     {
         return new static(
-            self::createFromFormat(
+            static::createFromFormat(
                 $value,
                 static::FORMAT,
                 new DateTimeZone(static::ZONE)

src/DateTime/Timestamp/TimestampMilliseconds.php

@@ -52,7 +52,7 @@ public static function fromString(string $value): static
         return new static(
             static::createFromFormat(
                 $secondsWithMicro,
-                self::FORMAT,
+                static::FORMAT,
                 new DateTimeZone(static::ZONE)
             )
         );

src/String/Json.php

@@ -29,7 +29,7 @@
      */
     public function __construct(string $value)
     {
-        self::assertJsonString($value);
+        static::assertJsonString($value);
 
         $this->value = $value;
     }

tests/Unit/Float/Alias/DoubleTest.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Float\Alias\Double;
+
+it('Double::fromFloat returns Double instance (late static binding)', function (): void {
+    $v = Double::fromFloat(3.14);
+
+    expect($v)->toBeInstanceOf(Double::class)
+        ->and($v::class)->toBe(Double::class)
+        ->and($v->value())->toBe(3.14);
+});
+
+it('Double::fromString returns Double instance (late static binding)', function (): void {
+    $v = Double::fromString('2.5');
+
+    expect($v)->toBeInstanceOf(Double::class)
+        ->and($v::class)->toBe(Double::class)
+        ->and($v->toString())->toBe('2.5');
+});

tests/Unit/Float/Alias/FloatTypeTest.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Float\Alias\FloatType;
+
+it('FloatType::fromFloat returns FloatType instance', function (): void {
+    $v = FloatType::fromFloat(1.25);
+
+    expect($v)->toBeInstanceOf(FloatType::class)
+        ->and($v::class)->toBe(FloatType::class)
+        ->and($v->value())->toBe(1.25);
+});
+
+it('FloatType::fromString returns FloatType instance', function (): void {
+    $v = FloatType::fromString('2.75');
+
+    expect($v)->toBeInstanceOf(FloatType::class)
+        ->and($v::class)->toBe(FloatType::class)
+        ->and($v->toString())->toBe('2.75');
+});

tests/Unit/Float/Alias/NonNegativeFloatTest.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Float\Alias\NonNegativeFloat;
+
+it('NonNegativeFloat::fromFloat returns NonNegativeFloat instance', function (): void {
+    $v = NonNegativeFloat::fromFloat(0.0);
+
+    expect($v)->toBeInstanceOf(NonNegativeFloat::class)
+        ->and($v::class)->toBe(NonNegativeFloat::class)
+        ->and($v->value())->toBe(0.0);
+});
+
+it('NonNegativeFloat::fromString returns NonNegativeFloat instance', function (): void {
+    $v = NonNegativeFloat::fromString('2.0');
+
+    expect($v)->toBeInstanceOf(NonNegativeFloat::class)
+        ->and($v::class)->toBe(NonNegativeFloat::class)
+        ->and($v->toString())->toBe('2');
+});

tests/Unit/Float/Alias/PositiveFloatTest.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Float\Alias\PositiveFloat;
+
+it('PositiveFloat::fromFloat returns PositiveFloat instance', function (): void {
+    $v = PositiveFloat::fromFloat(0.1);
+
+    expect($v)->toBeInstanceOf(PositiveFloat::class)
+        ->and($v::class)->toBe(PositiveFloat::class)
+        ->and($v->value())->toBe(0.1);
+});
+
+it('PositiveFloat::fromString returns PositiveFloat instance', function (): void {
+    $v = PositiveFloat::fromString('1.5');
+
+    expect($v)->toBeInstanceOf(PositiveFloat::class)
+        ->and($v::class)->toBe(PositiveFloat::class)
+        ->and($v->toString())->toBe('1.5');
+});

tests/Unit/Integer/Alias/IntTypeTest.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Integer\Alias\IntType;
+
+it('IntType alias factories return IntType instance', function (): void {
+    $a = IntType::fromInt(-5);
+    $b = IntType::fromString('10');
+
+    expect($a)->toBeInstanceOf(IntType::class)
+        ->and($a::class)->toBe(IntType::class)
+        ->and($a->value())->toBe(-5)
+        ->and($b)->toBeInstanceOf(IntType::class)
+        ->and($b->toString())->toBe('10');
+});

tests/Unit/Integer/Alias/IntegerTest.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Integer\Alias\Integer;
+
+it('Integer alias fromInt returns Integer alias instance', function (): void {
+    $v = Integer::fromInt(42);
+
+    expect($v)->toBeInstanceOf(Integer::class)
+        ->and($v::class)->toBe(Integer::class)
+        ->and($v->value())->toBe(42);
+});
+
+it('Integer alias fromString returns Integer alias instance', function (): void {
+    $v = Integer::fromString('7');
+
+    expect($v)->toBeInstanceOf(Integer::class)
+        ->and($v::class)->toBe(Integer::class)
+        ->and($v->toString())->toBe('7');
+});

tests/Unit/Integer/Alias/NonNegativeIntTest.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Integer\Alias\NonNegativeInt;
+
+it('NonNegativeInt alias factories return NonNegativeInt instance', function (): void {
+    $a = NonNegativeInt::fromInt(0);
+    $b = NonNegativeInt::fromString('12');
+
+    expect($a)->toBeInstanceOf(NonNegativeInt::class)
+        ->and($a::class)->toBe(NonNegativeInt::class)
+        ->and($a->value())->toBe(0)
+        ->and($b)->toBeInstanceOf(NonNegativeInt::class)
+        ->and($b->value())->toBe(12);
+});