Add unit tests for IntegerWeekDay, IntegerStandard, IntegerPositive, and IntegerNonNegative

- Introduced comprehensive tests for `tryFromString`, `tryFromInt`, `fromString`, and `fromInt` methods.
- Validated strict integer parsing, range, and type-specific constraints.
- Ensured exception handling and `Undefined` behavior for invalid inputs.

Author: georgedeploy

tests/Unit/Integer/IntegerNonNegative/IntegerNonNegativeTest.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Exception\IntegerTypeException;
+use PhpTypedValues\Integer\IntegerNonNegative;
+use PhpTypedValues\Undefined\Alias\Undefined;
+
+it('IntegerNonNegative::tryFromString returns value for >= 0', function (): void {
+    $v0 = IntegerNonNegative::tryFromString('0');
+    $v5 = IntegerNonNegative::tryFromString('5');
+
+    expect($v0)
+        ->toBeInstanceOf(IntegerNonNegative::class)
+        ->and($v0->value())
+        ->toBe(0)
+        ->and($v5)
+        ->toBeInstanceOf(IntegerNonNegative::class)
+        ->and($v5->value())
+        ->toBe(5);
+});
+
+it('IntegerNonNegative::tryFromString returns Undefined for negatives and non-integer strings', function (): void {
+    expect(IntegerNonNegative::tryFromString('-1'))
+        ->toBeInstanceOf(Undefined::class)
+        ->and(IntegerNonNegative::tryFromString('5.0'))
+        ->toBeInstanceOf(Undefined::class);
+});
+
+it('IntegerNonNegative::tryFromInt returns value for >= 0 and Undefined for negatives', function (): void {
+    $ok = IntegerNonNegative::tryFromInt(0);
+    $bad = IntegerNonNegative::tryFromInt(-10);
+
+    expect($ok)
+        ->toBeInstanceOf(IntegerNonNegative::class)
+        ->and($ok->value())
+        ->toBe(0)
+        ->and($bad)
+        ->toBeInstanceOf(Undefined::class);
+});
+
+it('IntegerNonNegative throws on negative values in ctor and fromInt', function (): void {
+    expect(fn() => new IntegerNonNegative(-1))
+        ->toThrow(IntegerTypeException::class, 'Expected non-negative integer, got "-1"')
+        ->and(fn() => IntegerNonNegative::fromInt(-10))
+        ->toThrow(IntegerTypeException::class, 'Expected non-negative integer, got "-10"');
+});
+
+it('IntegerNonNegative::fromString enforces strict integer and non-negativity', function (): void {
+    // Strict integer check
+    expect(fn() => IntegerNonNegative::fromString('5.0'))
+        ->toThrow(IntegerTypeException::class, 'String "5.0" has no valid strict integer value');
+
+    // Non-negativity check after casting
+    expect(fn() => IntegerNonNegative::fromString('-1'))
+        ->toThrow(IntegerTypeException::class, 'Expected non-negative integer, got "-1"');
+
+    // Success path
+    $v = IntegerNonNegative::fromString('0');
+    expect($v->value())->toBe(0);
+});

tests/Unit/Integer/IntegerPositive/IntegerPositiveTest.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Exception\IntegerTypeException;
+use PhpTypedValues\Integer\IntegerPositive;
+use PhpTypedValues\Undefined\Alias\Undefined;
+
+it('IntegerPositive::tryFromString returns value for > 0', function (): void {
+    $v = IntegerPositive::tryFromString('5');
+
+    expect($v)
+        ->toBeInstanceOf(IntegerPositive::class)
+        ->and($v->value())
+        ->toBe(5);
+});
+
+it('IntegerPositive::tryFromString returns Undefined for 0 and non-integer strings', function (): void {
+    expect(IntegerPositive::tryFromString('0'))
+        ->toBeInstanceOf(Undefined::class)
+        ->and(IntegerPositive::tryFromString('5.0'))
+        ->toBeInstanceOf(Undefined::class)
+        ->and(IntegerPositive::tryFromString('-3'))
+        ->toBeInstanceOf(Undefined::class);
+});
+
+it('IntegerPositive::tryFromInt returns value for positive int and Undefined otherwise', function (): void {
+    $ok = IntegerPositive::tryFromInt(10);
+    $bad = IntegerPositive::tryFromInt(-1);
+
+    expect($ok)
+        ->toBeInstanceOf(IntegerPositive::class)
+        ->and($ok->value())
+        ->toBe(10)
+        ->and($bad)
+        ->toBeInstanceOf(Undefined::class);
+});
+
+it('IntegerPositive throws on non-positive values in ctor and fromInt', function (): void {
+    expect(fn() => new IntegerPositive(0))
+        ->toThrow(IntegerTypeException::class, 'Expected positive integer, got "0"')
+        ->and(fn() => IntegerPositive::fromInt(-1))
+        ->toThrow(IntegerTypeException::class, 'Expected positive integer, got "-1"');
+});
+
+it('IntegerPositive::fromString enforces strict integer and positivity', function (): void {
+    // Strict integer check
+    expect(fn() => IntegerPositive::fromString('5.0'))
+        ->toThrow(IntegerTypeException::class, 'String "5.0" has no valid strict integer value');
+
+    // Positivity check after casting
+    expect(fn() => IntegerPositive::fromString('0'))
+        ->toThrow(IntegerTypeException::class, 'Expected positive integer, got "0"');
+
+    // Success path
+    $v = IntegerPositive::fromString('7');
+    expect($v->value())->toBe(7);
+});

tests/Unit/Integer/IntegerStandard/IntegerStandardTest.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Exception\IntegerTypeException;
+use PhpTypedValues\Integer\IntegerStandard;
+use PhpTypedValues\Undefined\Alias\Undefined;
+
+it('IntegerStandard::tryFromString returns value on valid integer string', function (): void {
+    $v = IntegerStandard::tryFromString('123');
+
+    expect($v)
+        ->toBeInstanceOf(IntegerStandard::class)
+        ->and($v->value())
+        ->toBe(123);
+});
+
+it('IntegerStandard::tryFromString returns Undefined on invalid integer string', function (): void {
+    $v = IntegerStandard::tryFromString('5.0');
+
+    expect($v)->toBeInstanceOf(Undefined::class);
+});
+
+it('IntegerStandard::tryFromInt always returns value for any int', function (): void {
+    $v = IntegerStandard::tryFromInt(-999);
+
+    expect($v)
+        ->toBeInstanceOf(IntegerStandard::class)
+        ->and($v->value())
+        ->toBe(-999);
+});
+
+it('IntegerStandard::fromInt returns instance and preserves value', function (): void {
+    $v = IntegerStandard::fromInt(42);
+
+    expect($v)
+        ->toBeInstanceOf(IntegerStandard::class)
+        ->and($v->value())->toBe(42)
+        ->and($v->toString())->toBe('42');
+});
+
+it('IntegerStandard::fromString throws on non-integer strings (strict check)', function (): void {
+    expect(fn() => IntegerStandard::fromString('12.3'))
+        ->toThrow(IntegerTypeException::class, 'String "12.3" has no valid strict integer value');
+});

tests/Unit/Integer/IntegerWeekDay/IntegerWeekDayTest.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Exception\IntegerTypeException;
+use PhpTypedValues\Integer\IntegerWeekDay;
+use PhpTypedValues\Undefined\Alias\Undefined;
+
+it('IntegerWeekDay::tryFromString returns value for 1..7', function (): void {
+    $v1 = IntegerWeekDay::tryFromString('1');
+    $v7 = IntegerWeekDay::tryFromString('7');
+
+    expect($v1)
+        ->toBeInstanceOf(IntegerWeekDay::class)
+        ->and($v1->value())
+        ->toBe(1)
+        ->and($v7)
+        ->toBeInstanceOf(IntegerWeekDay::class)
+        ->and($v7->value())
+        ->toBe(7);
+});
+
+it('IntegerWeekDay::tryFromString returns Undefined outside 1..7 and for non-integer strings', function (): void {
+    expect(IntegerWeekDay::tryFromString('0'))
+        ->toBeInstanceOf(Undefined::class)
+        ->and(IntegerWeekDay::tryFromString('8'))
+        ->toBeInstanceOf(Undefined::class)
+        ->and(IntegerWeekDay::tryFromString('3.0'))
+        ->toBeInstanceOf(Undefined::class);
+});
+
+it('IntegerWeekDay::tryFromInt returns value for 1..7 and Undefined otherwise', function (): void {
+    $ok = IntegerWeekDay::tryFromInt(3);
+    $bad = IntegerWeekDay::tryFromInt(0);
+
+    expect($ok)
+        ->toBeInstanceOf(IntegerWeekDay::class)
+        ->and($ok->value())
+        ->toBe(3)
+        ->and($bad)
+        ->toBeInstanceOf(Undefined::class);
+});
+
+it('IntegerWeekDay throws on values outside 1..7 in ctor and fromInt', function (): void {
+    expect(fn() => new IntegerWeekDay(0))
+        ->toThrow(IntegerTypeException::class, 'Expected value between 1-7, got "0"')
+        ->and(fn() => IntegerWeekDay::fromInt(8))
+        ->toThrow(IntegerTypeException::class, 'Expected value between 1-7, got "8"');
+});
+
+it('IntegerWeekDay::fromString enforces strict integer and range 1..7', function (): void {
+    // Strict integer check
+    expect(fn() => IntegerWeekDay::fromString('3.0'))
+        ->toThrow(IntegerTypeException::class, 'String "3.0" has no valid strict integer value');
+
+    // Range checks after casting
+    expect(fn() => IntegerWeekDay::fromString('0'))
+        ->toThrow(IntegerTypeException::class, 'Expected value between 1-7, got "0"')
+        ->and(fn() => IntegerWeekDay::fromString('8'))
+        ->toThrow(IntegerTypeException::class, 'Expected value between 1-7, got "8"');
+
+    // Success path
+    $v = IntegerWeekDay::fromString('6');
+    expect($v->value())->toBe(6);
+});