From cb3a78bfcf809174c5ecac185d61ca9058da7a33 Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Tue, 11 Jun 2024 21:53:44 +0200
Subject: [PATCH 01/14] Add Moment::mustBeEqualTo guard

---
 .php-cs-fixer.dist.php                        |  3 +
 src/Exception/MomentIsNotEqual.php            | 18 ++++
 src/Moment.php                                | 37 ++++++++
 tests/Moment/MustBeEqualToInTimeZoneTest.php  | 85 +++++++++++++++++++
 tests/Moment/MustBeEqualToTest.php            | 74 ++++++++++++++++
 .../Test/Exception/CustomMomentIsNotEqual.php |  9 ++
 .../CustomMomentIsNotEqualInTimeZone.php      |  9 ++
 7 files changed, 235 insertions(+)
 create mode 100644 src/Exception/MomentIsNotEqual.php
 create mode 100644 tests/Moment/MustBeEqualToInTimeZoneTest.php
 create mode 100644 tests/Moment/MustBeEqualToTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotEqual.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotEqualInTimeZone.php

diff --git a/.php-cs-fixer.dist.php b/.php-cs-fixer.dist.php
index 6fb2528..d93c4e4 100644
--- a/.php-cs-fixer.dist.php
+++ b/.php-cs-fixer.dist.php
@@ -41,5 +41,8 @@
 
         // Nullable types should be explicit even with default values
         'nullable_type_declaration_for_default_null_value' => false,
+
+        // Throw in a single line is worse to read when using ternary operator
+        'single_line_throw' => false,
     ])
     ->setFinder($finder);
diff --git a/src/Exception/MomentIsNotEqual.php b/src/Exception/MomentIsNotEqual.php
new file mode 100644
index 0000000..5bf1bd9
--- /dev/null
+++ b/src/Exception/MomentIsNotEqual.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsNotEqual extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is not equal.');
+    }
+}
diff --git a/src/Moment.php b/src/Moment.php
index cf7f051..bd40a53 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -501,4 +501,41 @@ public function midnightInTimeZone(\DateTimeZone $timeZone): self
             ->midnight()
             ->toTimeZone($originalTimeZone);
     }
+
+    // -- Guards
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotEqual
+     */
+    public function mustBeEqualTo(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotEqualTo($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotEqual();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotEqual
+     */
+    public function mustBeEqualToInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotEqualToInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotEqual();
+        }
+    }
 }
diff --git a/tests/Moment/MustBeEqualToInTimeZoneTest.php b/tests/Moment/MustBeEqualToInTimeZoneTest.php
new file mode 100644
index 0000000..b7de706
--- /dev/null
+++ b/tests/Moment/MustBeEqualToInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotEqual;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotEqualInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeEqualToInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeEqualToInTimeZone
+     */
+    public function must_be_equal_to_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeEqualToInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotEqual::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('16:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotEqualInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('16:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsNotEqualInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustBeEqualToTest.php b/tests/Moment/MustBeEqualToTest.php
new file mode 100644
index 0000000..8b4af9a
--- /dev/null
+++ b/tests/Moment/MustBeEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotEqual;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotEqual;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeEqualToTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeEqualTo
+     */
+    public function must_be_equal_to_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotEqual::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2023-10-08 16:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotEqual::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-11-08 15:00:00'),
+                static fn () => new CustomMomentIsNotEqual(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotEqual.php b/tests/Test/Exception/CustomMomentIsNotEqual.php
new file mode 100644
index 0000000..1d33877
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotEqual.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotEqual extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotEqualInTimeZone.php b/tests/Test/Exception/CustomMomentIsNotEqualInTimeZone.php
new file mode 100644
index 0000000..2cef456
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotEqualInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotEqualInTimeZone extends \InvalidArgumentException
+{
+}

From 5d3b330f93341ffb3e2b3976d081c2acd4399cbd Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Thu, 13 Jun 2024 14:17:02 +0200
Subject: [PATCH 02/14] Added mustNotBeEqualTo and mustNotBeEqualToInTimeZone

---
 src/Exception/MomentIsEqual.php               | 18 ++++
 src/Exception/MomentIsNotEqual.php            |  2 +-
 src/Moment.php                                | 35 ++++++++
 .../Moment/MustNotBeEqualToInTimeZoneTest.php | 85 +++++++++++++++++++
 tests/Moment/MustNotBeEqualToTest.php         | 74 ++++++++++++++++
 tests/Test/Exception/CustomMomentIsEqual.php  |  9 ++
 .../CustomMomentIsEqualInTimeZone.php         |  9 ++
 7 files changed, 231 insertions(+), 1 deletion(-)
 create mode 100644 src/Exception/MomentIsEqual.php
 create mode 100644 tests/Moment/MustNotBeEqualToInTimeZoneTest.php
 create mode 100644 tests/Moment/MustNotBeEqualToTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsEqual.php
 create mode 100644 tests/Test/Exception/CustomMomentIsEqualInTimeZone.php

diff --git a/src/Exception/MomentIsEqual.php b/src/Exception/MomentIsEqual.php
new file mode 100644
index 0000000..a76ae0e
--- /dev/null
+++ b/src/Exception/MomentIsEqual.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsEqual extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is equal but must not be.');
+    }
+}
diff --git a/src/Exception/MomentIsNotEqual.php b/src/Exception/MomentIsNotEqual.php
index 5bf1bd9..2b69f62 100644
--- a/src/Exception/MomentIsNotEqual.php
+++ b/src/Exception/MomentIsNotEqual.php
@@ -13,6 +13,6 @@ final class MomentIsNotEqual extends \InvalidArgumentException
 {
     public function __construct()
     {
-        parent::__construct('The moment is not equal.');
+        parent::__construct('The moment is not equal but must be.');
     }
 }
diff --git a/src/Moment.php b/src/Moment.php
index bd40a53..bf75255 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -538,4 +538,39 @@ public function mustBeEqualToInTimeZone(
                 : new Exception\MomentIsNotEqual();
         }
     }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsEqual
+     */
+    public function mustNotBeEqualTo(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isEqualTo($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsEqual();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsEqual
+     */
+    public function mustNotBeEqualToInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isEqualToInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsEqual();
+        }
+    }
 }
diff --git a/tests/Moment/MustNotBeEqualToInTimeZoneTest.php b/tests/Moment/MustNotBeEqualToInTimeZoneTest.php
new file mode 100644
index 0000000..72234d2
--- /dev/null
+++ b/tests/Moment/MustNotBeEqualToInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsEqual;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsEqualInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeEqualToInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeEqualToInTimeZone
+     */
+    public function must_not_be_equal_to_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeEqualToInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('16:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsEqual::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsEqualInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsEqualInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustNotBeEqualToTest.php b/tests/Moment/MustNotBeEqualToTest.php
new file mode 100644
index 0000000..1f7a5bd
--- /dev/null
+++ b/tests/Moment/MustNotBeEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsEqual;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsEqual;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeEqualToTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeEqualTo
+     */
+    public function must_not_be_equal_to_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 16:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsEqual::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsEqual::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                static fn () => new CustomMomentIsEqual(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsEqual.php b/tests/Test/Exception/CustomMomentIsEqual.php
new file mode 100644
index 0000000..308d230
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsEqual.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsEqual extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsEqualInTimeZone.php b/tests/Test/Exception/CustomMomentIsEqualInTimeZone.php
new file mode 100644
index 0000000..5ae7bec
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsEqualInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsEqualInTimeZone extends \InvalidArgumentException
+{
+}

From a86db3c992f61cee7db48d27c7e60f0d8f5f9255 Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Thu, 13 Jun 2024 15:07:49 +0200
Subject: [PATCH 03/14] Add mustBeAfter and mustBeAfterInTimeZone

---
 src/Exception/MomentIsNotAfter.php            | 18 ++++
 src/Moment.php                                | 35 ++++++++
 tests/Moment/MustBeAfterInTimeZoneTest.php    | 85 +++++++++++++++++++
 tests/Moment/MustBeAfterTest.php              | 74 ++++++++++++++++
 .../Test/Exception/CustomMomentIsNotAfter.php |  9 ++
 .../CustomMomentIsNotAfterInTimeZone.php      |  9 ++
 6 files changed, 230 insertions(+)
 create mode 100644 src/Exception/MomentIsNotAfter.php
 create mode 100644 tests/Moment/MustBeAfterInTimeZoneTest.php
 create mode 100644 tests/Moment/MustBeAfterTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotAfter.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotAfterInTimeZone.php

diff --git a/src/Exception/MomentIsNotAfter.php b/src/Exception/MomentIsNotAfter.php
new file mode 100644
index 0000000..2656d2d
--- /dev/null
+++ b/src/Exception/MomentIsNotAfter.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsNotAfter extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is not after but must be.');
+    }
+}
diff --git a/src/Moment.php b/src/Moment.php
index bf75255..54375fa 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -573,4 +573,39 @@ public function mustNotBeEqualToInTimeZone(
                 : new Exception\MomentIsEqual();
         }
     }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotAfter
+     */
+    public function mustBeAfter(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotAfter($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotAfter();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotAfter
+     */
+    public function mustBeAfterInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotAfterInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotAfter();
+        }
+    }
 }
diff --git a/tests/Moment/MustBeAfterInTimeZoneTest.php b/tests/Moment/MustBeAfterInTimeZoneTest.php
new file mode 100644
index 0000000..37adf64
--- /dev/null
+++ b/tests/Moment/MustBeAfterInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotAfter;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotAfterInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeAfterInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeAfterInTimeZone
+     */
+    public function must_be_after_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeAfterInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 16:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotAfter::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotAfterInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsNotAfterInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustBeAfterTest.php b/tests/Moment/MustBeAfterTest.php
new file mode 100644
index 0000000..88f6338
--- /dev/null
+++ b/tests/Moment/MustBeAfterTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotAfter;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotAfter;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeAfterTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeAfter
+     */
+    public function must_be_after_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeAfter(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotAfter::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2023-10-08 15:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotAfter::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                static fn () => new CustomMomentIsNotAfter(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotAfter.php b/tests/Test/Exception/CustomMomentIsNotAfter.php
new file mode 100644
index 0000000..dec686c
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotAfter.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotAfter extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotAfterInTimeZone.php b/tests/Test/Exception/CustomMomentIsNotAfterInTimeZone.php
new file mode 100644
index 0000000..c579fd8
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotAfterInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotAfterInTimeZone extends \InvalidArgumentException
+{
+}

From a8cdc297822def6699fa15b81da2b51f38ec0327 Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Thu, 13 Jun 2024 15:11:29 +0200
Subject: [PATCH 04/14] Update upload action

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8f4aed6..bd96f04 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -39,7 +39,7 @@ jobs:
         run: make php-8.2-tests-ci
 
       - name: Upload to Codecov
-        uses: codecov/codecov-action@v2
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODE_COV_TOKEN }}
           files: ./coverage.xml

From 55be9da90c2557a19a7ed3a5f57b56aabc2b5ea1 Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Thu, 13 Jun 2024 15:16:10 +0200
Subject: [PATCH 05/14] Fix token name for upload

---
 .github/workflows/ci.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bd96f04..4e7b3cd 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -41,8 +41,9 @@ jobs:
       - name: Upload to Codecov
         uses: codecov/codecov-action@v4
         with:
-          token: ${{ secrets.CODE_COV_TOKEN }}
+          fail_ci_if_error: true
           files: ./coverage.xml
+          token: ${{ secrets.CODECOV_TOKEN }}
           verbose: true
 
   test-8-3:

From bc2d185a76f9bb16f4062f7db8fcec70b7cdedaa Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Thu, 13 Jun 2024 17:19:28 +0200
Subject: [PATCH 06/14] Add mustNotBeAfter and mustNotBeAfterInTimeZone

---
 src/Exception/MomentIsAfter.php               | 18 ++++
 src/Moment.php                                | 35 ++++++++
 tests/Moment/MustNotBeAfterInTimeZoneTest.php | 85 +++++++++++++++++++
 tests/Moment/MustNotBeAfterTest.php           | 74 ++++++++++++++++
 tests/Test/Exception/CustomMomentIsAfter.php  |  9 ++
 .../CustomMomentIsAfterInTimeZone.php         |  9 ++
 6 files changed, 230 insertions(+)
 create mode 100644 src/Exception/MomentIsAfter.php
 create mode 100644 tests/Moment/MustNotBeAfterInTimeZoneTest.php
 create mode 100644 tests/Moment/MustNotBeAfterTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsAfter.php
 create mode 100644 tests/Test/Exception/CustomMomentIsAfterInTimeZone.php

diff --git a/src/Exception/MomentIsAfter.php b/src/Exception/MomentIsAfter.php
new file mode 100644
index 0000000..f6dc394
--- /dev/null
+++ b/src/Exception/MomentIsAfter.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsAfter extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is after but must not be.');
+    }
+}
diff --git a/src/Moment.php b/src/Moment.php
index 54375fa..8c6fd5a 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -608,4 +608,39 @@ public function mustBeAfterInTimeZone(
                 : new Exception\MomentIsNotAfter();
         }
     }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsAfter
+     */
+    public function mustNotBeAfter(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isAfter($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsAfter();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsAfter
+     */
+    public function mustNotBeAfterInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isAfterInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsAfter();
+        }
+    }
 }
diff --git a/tests/Moment/MustNotBeAfterInTimeZoneTest.php b/tests/Moment/MustNotBeAfterInTimeZoneTest.php
new file mode 100644
index 0000000..b0652bc
--- /dev/null
+++ b/tests/Moment/MustNotBeAfterInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsAfter;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsAfterInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeAfterInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeAfterInTimeZone
+     */
+    public function must_not_be_after_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeAfterInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsAfter::class,
+                Moment::fromStringInTimeZone('2022-10-08 16:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsAfterInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 16:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsAfterInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustNotBeAfterTest.php b/tests/Moment/MustNotBeAfterTest.php
new file mode 100644
index 0000000..ec5aa74
--- /dev/null
+++ b/tests/Moment/MustNotBeAfterTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsAfter;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsAfter;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeAfterTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeAfter
+     */
+    public function must_not_be_after_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeAfter(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsAfter::class,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsAfter::class,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                static fn () => new CustomMomentIsAfter(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsAfter.php b/tests/Test/Exception/CustomMomentIsAfter.php
new file mode 100644
index 0000000..e81eb72
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsAfter.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsAfter extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsAfterInTimeZone.php b/tests/Test/Exception/CustomMomentIsAfterInTimeZone.php
new file mode 100644
index 0000000..3efaba7
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsAfterInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsAfterInTimeZone extends \InvalidArgumentException
+{
+}

From fded4dd8dd8886a6f6a7f6fa55b910593c9c986e Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Thu, 13 Jun 2024 17:23:30 +0200
Subject: [PATCH 07/14] Add hint about amount of tests

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c4c692d..1be3539 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ Additionally, the package provides a streamlined way to have the system running
 
 This Symfony bundle includes Symfony normalizers for automatic normalization and denormalization and Doctrine types to store the objects directly in the database. 
 
-As it's a central part of an application, it's tested thoroughly (including mutation testing).
+As it's a central part of an application, it's tested thoroughly (including mutation testing). Currently, more than 80% of the lines of code in this repository are tests.
 
 [![Latest Stable Version](http://poser.pugx.org/digital-craftsman/date-time-precision/v)](https://packagist.org/packages/digital-craftsman/date-time-precision)
 [![PHP Version Require](http://poser.pugx.org/digital-craftsman/date-time-precision/require/php)](https://packagist.org/packages/digital-craftsman/date-time-precision)

From ccbc7afd4026377524bb5e842503e6be3e80937a Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Fri, 14 Jun 2024 08:46:51 +0200
Subject: [PATCH 08/14] Added mustBeAfterOrEqualTo and
 mustBeAfterOrEqualToInTimeZone

---
 src/Exception/MomentIsNotAfterOrEqualTo.php   | 18 ++++
 src/Moment.php                                | 35 ++++++++
 .../MustBeAfterOrEqualToInTimeZoneTest.php    | 85 +++++++++++++++++++
 tests/Moment/MustBeAfterOrEqualToTest.php     | 74 ++++++++++++++++
 .../CustomMomentIsNotAfterOrEqualTo.php       |  9 ++
 ...tomMomentIsNotAfterOrEqualToInTimeZone.php |  9 ++
 6 files changed, 230 insertions(+)
 create mode 100644 src/Exception/MomentIsNotAfterOrEqualTo.php
 create mode 100644 tests/Moment/MustBeAfterOrEqualToInTimeZoneTest.php
 create mode 100644 tests/Moment/MustBeAfterOrEqualToTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotAfterOrEqualTo.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotAfterOrEqualToInTimeZone.php

diff --git a/src/Exception/MomentIsNotAfterOrEqualTo.php b/src/Exception/MomentIsNotAfterOrEqualTo.php
new file mode 100644
index 0000000..bc9c7e3
--- /dev/null
+++ b/src/Exception/MomentIsNotAfterOrEqualTo.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsNotAfterOrEqualTo extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is not after or equal to but must be.');
+    }
+}
diff --git a/src/Moment.php b/src/Moment.php
index 8c6fd5a..d32c680 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -643,4 +643,39 @@ public function mustNotBeAfterInTimeZone(
                 : new Exception\MomentIsAfter();
         }
     }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotAfterOrEqualTo
+     */
+    public function mustBeAfterOrEqualTo(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotAfterOrEqualTo($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotAfterOrEqualTo();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotAfterOrEqualTo
+     */
+    public function mustBeAfterOrEqualToInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotAfterOrEqualToInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotAfterOrEqualTo();
+        }
+    }
 }
diff --git a/tests/Moment/MustBeAfterOrEqualToInTimeZoneTest.php b/tests/Moment/MustBeAfterOrEqualToInTimeZoneTest.php
new file mode 100644
index 0000000..98272a3
--- /dev/null
+++ b/tests/Moment/MustBeAfterOrEqualToInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotAfterOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotAfterOrEqualToInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeAfterOrEqualToInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeAfterOrEqualToInTimeZone
+     */
+    public function must_be_after_or_equal_to_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeAfterOrEqualToInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 16:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotAfterOrEqualTo::class,
+                Moment::fromStringInTimeZone('2022-10-08 14:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotAfterOrEqualToInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 14:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsNotAfterOrEqualToInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustBeAfterOrEqualToTest.php b/tests/Moment/MustBeAfterOrEqualToTest.php
new file mode 100644
index 0000000..63bb4ac
--- /dev/null
+++ b/tests/Moment/MustBeAfterOrEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotAfterOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotAfterOrEqualTo;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeAfterOrEqualToTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeAfterOrEqualTo
+     */
+    public function must_be_after_or_equal_to_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeAfterOrEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotAfterOrEqualTo::class,
+                Moment::fromString('2022-10-08 14:00:00'),
+                Moment::fromString('2023-10-08 15:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotAfterOrEqualTo::class,
+                Moment::fromString('2022-10-08 14:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                static fn () => new CustomMomentIsNotAfterOrEqualTo(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotAfterOrEqualTo.php b/tests/Test/Exception/CustomMomentIsNotAfterOrEqualTo.php
new file mode 100644
index 0000000..01a1754
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotAfterOrEqualTo.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotAfterOrEqualTo extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotAfterOrEqualToInTimeZone.php b/tests/Test/Exception/CustomMomentIsNotAfterOrEqualToInTimeZone.php
new file mode 100644
index 0000000..304c797
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotAfterOrEqualToInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotAfterOrEqualToInTimeZone extends \InvalidArgumentException
+{
+}

From aa964836d95d7cac731221eda0a407b817b60ea5 Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Fri, 14 Jun 2024 13:09:29 +0200
Subject: [PATCH 09/14] Added mustNotBeAfterOrEqualTo and
 mustNotBeAfterOrEqualToInTimeZone

---
 src/Exception/MomentIsAfterOrEqualTo.php      | 18 ++++
 src/Moment.php                                | 35 ++++++++
 .../MustNotBeAfterOrEqualToInTimeZoneTest.php | 85 +++++++++++++++++++
 tests/Moment/MustNotBeAfterOrEqualToTest.php  | 74 ++++++++++++++++
 .../CustomMomentIsAfterOrEqualTo.php          |  9 ++
 ...CustomMomentIsAfterOrEqualToInTimeZone.php |  9 ++
 6 files changed, 230 insertions(+)
 create mode 100644 src/Exception/MomentIsAfterOrEqualTo.php
 create mode 100644 tests/Moment/MustNotBeAfterOrEqualToInTimeZoneTest.php
 create mode 100644 tests/Moment/MustNotBeAfterOrEqualToTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsAfterOrEqualTo.php
 create mode 100644 tests/Test/Exception/CustomMomentIsAfterOrEqualToInTimeZone.php

diff --git a/src/Exception/MomentIsAfterOrEqualTo.php b/src/Exception/MomentIsAfterOrEqualTo.php
new file mode 100644
index 0000000..37f8387
--- /dev/null
+++ b/src/Exception/MomentIsAfterOrEqualTo.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsAfterOrEqualTo extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is after or equal to but must not be.');
+    }
+}
diff --git a/src/Moment.php b/src/Moment.php
index d32c680..149cdc4 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -678,4 +678,39 @@ public function mustBeAfterOrEqualToInTimeZone(
                 : new Exception\MomentIsNotAfterOrEqualTo();
         }
     }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsAfterOrEqualTo
+     */
+    public function mustNotBeAfterOrEqualTo(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isAfterOrEqualTo($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsAfterOrEqualTo();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsAfterOrEqualTo
+     */
+    public function mustNotBeAfterOrEqualToInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isAfterOrEqualToInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsAfterOrEqualTo();
+        }
+    }
 }
diff --git a/tests/Moment/MustNotBeAfterOrEqualToInTimeZoneTest.php b/tests/Moment/MustNotBeAfterOrEqualToInTimeZoneTest.php
new file mode 100644
index 0000000..63e5ff4
--- /dev/null
+++ b/tests/Moment/MustNotBeAfterOrEqualToInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsAfterOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsAfterOrEqualToInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeAfterOrEqualToInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeAfterOrEqualToInTimeZone
+     */
+    public function must_not_be_after_or_equal_to_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeAfterOrEqualToInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 14:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsAfterOrEqualTo::class,
+                Moment::fromStringInTimeZone('2022-10-08 16:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsAfterOrEqualToInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 16:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsAfterOrEqualToInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustNotBeAfterOrEqualToTest.php b/tests/Moment/MustNotBeAfterOrEqualToTest.php
new file mode 100644
index 0000000..c93d86f
--- /dev/null
+++ b/tests/Moment/MustNotBeAfterOrEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsAfterOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsAfterOrEqualTo;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeAfterOrEqualToTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeAfterOrEqualTo
+     */
+    public function must_not_be_after_or_equal_to_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeAfterOrEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 14:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsAfterOrEqualTo::class,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsAfterOrEqualTo::class,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                static fn () => new CustomMomentIsAfterOrEqualTo(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsAfterOrEqualTo.php b/tests/Test/Exception/CustomMomentIsAfterOrEqualTo.php
new file mode 100644
index 0000000..4a0d825
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsAfterOrEqualTo.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsAfterOrEqualTo extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsAfterOrEqualToInTimeZone.php b/tests/Test/Exception/CustomMomentIsAfterOrEqualToInTimeZone.php
new file mode 100644
index 0000000..b2573b6
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsAfterOrEqualToInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsAfterOrEqualToInTimeZone extends \InvalidArgumentException
+{
+}

From 25a65383e99a891a73a7b050bb9717bfa1471c79 Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Mon, 17 Jun 2024 20:56:16 +0200
Subject: [PATCH 10/14] Add mustBeBefore and mustBeBeforeInTimeZone

---
 src/Exception/MomentIsNotBefore.php           | 18 ++++
 src/Moment.php                                | 35 ++++++++
 tests/Moment/MustBeBeforeInTimeZoneTest.php   | 85 +++++++++++++++++++
 tests/Moment/MustBeBeforeTest.php             | 74 ++++++++++++++++
 .../Exception/CustomMomentIsNotBefore.php     |  9 ++
 .../CustomMomentIsNotBeforeInTimeZone.php     |  9 ++
 6 files changed, 230 insertions(+)
 create mode 100644 src/Exception/MomentIsNotBefore.php
 create mode 100644 tests/Moment/MustBeBeforeInTimeZoneTest.php
 create mode 100644 tests/Moment/MustBeBeforeTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotBefore.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotBeforeInTimeZone.php

diff --git a/src/Exception/MomentIsNotBefore.php b/src/Exception/MomentIsNotBefore.php
new file mode 100644
index 0000000..99357c2
--- /dev/null
+++ b/src/Exception/MomentIsNotBefore.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsNotBefore extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is not before but must be.');
+    }
+}
diff --git a/src/Moment.php b/src/Moment.php
index 149cdc4..10993d3 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -713,4 +713,39 @@ public function mustNotBeAfterOrEqualToInTimeZone(
                 : new Exception\MomentIsAfterOrEqualTo();
         }
     }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotBefore
+     */
+    public function mustBeBefore(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotBefore($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotBefore();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotBefore
+     */
+    public function mustBeBeforeInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotBeforeInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotBefore();
+        }
+    }
 }
diff --git a/tests/Moment/MustBeBeforeInTimeZoneTest.php b/tests/Moment/MustBeBeforeInTimeZoneTest.php
new file mode 100644
index 0000000..a10cf66
--- /dev/null
+++ b/tests/Moment/MustBeBeforeInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotBefore;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotBeforeInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeBeforeInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeBeforeInTimeZone
+     */
+    public function must_be_before_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeBeforeInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('16:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotBefore::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotBeforeInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsNotBeforeInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustBeBeforeTest.php b/tests/Moment/MustBeBeforeTest.php
new file mode 100644
index 0000000..113b47b
--- /dev/null
+++ b/tests/Moment/MustBeBeforeTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotBefore;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotBefore;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeBeforeTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeBefore
+     */
+    public function must_be_before_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeBefore(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 16:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotBefore::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotBefore::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                static fn () => new CustomMomentIsNotBefore(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotBefore.php b/tests/Test/Exception/CustomMomentIsNotBefore.php
new file mode 100644
index 0000000..d829e54
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotBefore.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotBefore extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotBeforeInTimeZone.php b/tests/Test/Exception/CustomMomentIsNotBeforeInTimeZone.php
new file mode 100644
index 0000000..398c892
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotBeforeInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotBeforeInTimeZone extends \InvalidArgumentException
+{
+}

From 5c9ad4f80bdfffef69e8f3c258a6cce7b94295e4 Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Mon, 17 Jun 2024 21:06:07 +0200
Subject: [PATCH 11/14] Added mustNotBeBefore and mustNotBeBeforeInTimeZone

---
 src/Exception/MomentIsBefore.php              | 18 ++++
 src/Moment.php                                | 35 ++++++++
 .../Moment/MustNotBeBeforeInTimeZoneTest.php  | 85 +++++++++++++++++++
 tests/Moment/MustNotBeBeforeTest.php          | 74 ++++++++++++++++
 tests/Test/Exception/CustomMomentIsBefore.php |  9 ++
 .../CustomMomentIsBeforeInTimeZone.php        |  9 ++
 6 files changed, 230 insertions(+)
 create mode 100644 src/Exception/MomentIsBefore.php
 create mode 100644 tests/Moment/MustNotBeBeforeInTimeZoneTest.php
 create mode 100644 tests/Moment/MustNotBeBeforeTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsBefore.php
 create mode 100644 tests/Test/Exception/CustomMomentIsBeforeInTimeZone.php

diff --git a/src/Exception/MomentIsBefore.php b/src/Exception/MomentIsBefore.php
new file mode 100644
index 0000000..f9221f0
--- /dev/null
+++ b/src/Exception/MomentIsBefore.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsBefore extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is before but must not be.');
+    }
+}
diff --git a/src/Moment.php b/src/Moment.php
index 10993d3..8292522 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -748,4 +748,39 @@ public function mustBeBeforeInTimeZone(
                 : new Exception\MomentIsNotBefore();
         }
     }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsBefore
+     */
+    public function mustNotBeBefore(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isBefore($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsBefore();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsBefore
+     */
+    public function mustNotBeBeforeInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isBeforeInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsBefore();
+        }
+    }
 }
diff --git a/tests/Moment/MustNotBeBeforeInTimeZoneTest.php b/tests/Moment/MustNotBeBeforeInTimeZoneTest.php
new file mode 100644
index 0000000..5f79d7c
--- /dev/null
+++ b/tests/Moment/MustNotBeBeforeInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsBefore;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsBeforeInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeBeforeInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeBeforeInTimeZone
+     */
+    public function must_not_be_before_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeBeforeInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsBefore::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('16:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsBeforeInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('16:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsBeforeInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustNotBeBeforeTest.php b/tests/Moment/MustNotBeBeforeTest.php
new file mode 100644
index 0000000..8f3038c
--- /dev/null
+++ b/tests/Moment/MustNotBeBeforeTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsBefore;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsBefore;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeBeforeTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeBefore
+     */
+    public function must_not_be_before_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeBefore(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 16:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsBefore::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 16:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsBefore::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 16:00:00'),
+                static fn () => new CustomMomentIsBefore(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsBefore.php b/tests/Test/Exception/CustomMomentIsBefore.php
new file mode 100644
index 0000000..98acfd6
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsBefore.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsBefore extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsBeforeInTimeZone.php b/tests/Test/Exception/CustomMomentIsBeforeInTimeZone.php
new file mode 100644
index 0000000..ae4ef73
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsBeforeInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsBeforeInTimeZone extends \InvalidArgumentException
+{
+}

From 0089e82cf754638c31f9a8bcf0db337621f2444f Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Mon, 17 Jun 2024 21:17:24 +0200
Subject: [PATCH 12/14] Added mustBeBeforeOrEqualTo and
 mustBeBeforeOrEqualToInTimeZone

---
 src/Exception/MomentIsNotBeforeOrEqualTo.php  | 18 ++++
 src/Moment.php                                | 35 ++++++++
 .../MustBeBeforeOrEqualToInTimeZoneTest.php   | 85 +++++++++++++++++++
 tests/Moment/MustBeBeforeOrEqualToTest.php    | 74 ++++++++++++++++
 .../CustomMomentIsNotBeforeOrEqualTo.php      |  9 ++
 ...omMomentIsNotBeforeOrEqualToInTimeZone.php |  9 ++
 6 files changed, 230 insertions(+)
 create mode 100644 src/Exception/MomentIsNotBeforeOrEqualTo.php
 create mode 100644 tests/Moment/MustBeBeforeOrEqualToInTimeZoneTest.php
 create mode 100644 tests/Moment/MustBeBeforeOrEqualToTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotBeforeOrEqualTo.php
 create mode 100644 tests/Test/Exception/CustomMomentIsNotBeforeOrEqualToInTimeZone.php

diff --git a/src/Exception/MomentIsNotBeforeOrEqualTo.php b/src/Exception/MomentIsNotBeforeOrEqualTo.php
new file mode 100644
index 0000000..78a6a9a
--- /dev/null
+++ b/src/Exception/MomentIsNotBeforeOrEqualTo.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsNotBeforeOrEqualTo extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is not before or equal to but must be.');
+    }
+}
diff --git a/src/Moment.php b/src/Moment.php
index 8292522..f577ee7 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -783,4 +783,39 @@ public function mustNotBeBeforeInTimeZone(
                 : new Exception\MomentIsBefore();
         }
     }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotBeforeOrEqualTo
+     */
+    public function mustBeBeforeOrEqualTo(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotBeforeOrEqualTo($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotBeforeOrEqualTo();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsNotBeforeOrEqualTo
+     */
+    public function mustBeBeforeOrEqualToInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotBeforeOrEqualToInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsNotBeforeOrEqualTo();
+        }
+    }
 }
diff --git a/tests/Moment/MustBeBeforeOrEqualToInTimeZoneTest.php b/tests/Moment/MustBeBeforeOrEqualToInTimeZoneTest.php
new file mode 100644
index 0000000..bf497c7
--- /dev/null
+++ b/tests/Moment/MustBeBeforeOrEqualToInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotBeforeOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotBeforeOrEqualToInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeBeforeOrEqualToInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeBeforeOrEqualToInTimeZone
+     */
+    public function must_be_before_or_equal_to_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeBeforeOrEqualToInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('16:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotBeforeOrEqualTo::class,
+                Moment::fromStringInTimeZone('2022-10-08 16:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotBeforeOrEqualToInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 16:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsNotBeforeOrEqualToInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustBeBeforeOrEqualToTest.php b/tests/Moment/MustBeBeforeOrEqualToTest.php
new file mode 100644
index 0000000..9456f46
--- /dev/null
+++ b/tests/Moment/MustBeBeforeOrEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsNotBeforeOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsNotBeforeOrEqualTo;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustBeBeforeOrEqualToTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeBeforeOrEqualTo
+     */
+    public function must_be_before_or_equal_to_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustBeBeforeOrEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 16:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsNotBeforeOrEqualTo::class,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsNotBeforeOrEqualTo::class,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                static fn () => new CustomMomentIsNotBeforeOrEqualTo(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotBeforeOrEqualTo.php b/tests/Test/Exception/CustomMomentIsNotBeforeOrEqualTo.php
new file mode 100644
index 0000000..b0f8663
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotBeforeOrEqualTo.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotBeforeOrEqualTo extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsNotBeforeOrEqualToInTimeZone.php b/tests/Test/Exception/CustomMomentIsNotBeforeOrEqualToInTimeZone.php
new file mode 100644
index 0000000..480a548
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsNotBeforeOrEqualToInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsNotBeforeOrEqualToInTimeZone extends \InvalidArgumentException
+{
+}

From 837812706b4b8eb8673e896f554767afff280e65 Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Mon, 17 Jun 2024 21:23:31 +0200
Subject: [PATCH 13/14] Added mustNotBeBeforeOrEqualTo and
 mustNotBeBeforeOrEqualToInTimeZone

---
 src/Exception/MomentIsBeforeOrEqualTo.php     | 18 ++++
 src/Moment.php                                | 35 ++++++++
 ...MustNotBeBeforeOrEqualToInTimeZoneTest.php | 85 +++++++++++++++++++
 tests/Moment/MustNotBeBeforeOrEqualToTest.php | 74 ++++++++++++++++
 .../CustomMomentIsBeforeOrEqualTo.php         |  9 ++
 ...ustomMomentIsBeforeOrEqualToInTimeZone.php |  9 ++
 6 files changed, 230 insertions(+)
 create mode 100644 src/Exception/MomentIsBeforeOrEqualTo.php
 create mode 100644 tests/Moment/MustNotBeBeforeOrEqualToInTimeZoneTest.php
 create mode 100644 tests/Moment/MustNotBeBeforeOrEqualToTest.php
 create mode 100644 tests/Test/Exception/CustomMomentIsBeforeOrEqualTo.php
 create mode 100644 tests/Test/Exception/CustomMomentIsBeforeOrEqualToInTimeZone.php

diff --git a/src/Exception/MomentIsBeforeOrEqualTo.php b/src/Exception/MomentIsBeforeOrEqualTo.php
new file mode 100644
index 0000000..2461975
--- /dev/null
+++ b/src/Exception/MomentIsBeforeOrEqualTo.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class MomentIsBeforeOrEqualTo extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The moment is before or equal to but must not be.');
+    }
+}
diff --git a/src/Moment.php b/src/Moment.php
index f577ee7..a91ca59 100644
--- a/src/Moment.php
+++ b/src/Moment.php
@@ -818,4 +818,39 @@ public function mustBeBeforeOrEqualToInTimeZone(
                 : new Exception\MomentIsNotBeforeOrEqualTo();
         }
     }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsBeforeOrEqualTo
+     */
+    public function mustNotBeBeforeOrEqualTo(
+        self $moment,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isBeforeOrEqualTo($moment)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsBeforeOrEqualTo();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\MomentIsBeforeOrEqualTo
+     */
+    public function mustNotBeBeforeOrEqualToInTimeZone(
+        Time | Weekday | Date | Month | Year $moment,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isBeforeOrEqualToInTimeZone($moment, $timeZone)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\MomentIsBeforeOrEqualTo();
+        }
+    }
 }
diff --git a/tests/Moment/MustNotBeBeforeOrEqualToInTimeZoneTest.php b/tests/Moment/MustNotBeBeforeOrEqualToInTimeZoneTest.php
new file mode 100644
index 0000000..61fefd5
--- /dev/null
+++ b/tests/Moment/MustNotBeBeforeOrEqualToInTimeZoneTest.php
@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsBeforeOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Month;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsBeforeOrEqualToInTimeZone;
+use DigitalCraftsman\DateTimePrecision\Time;
+use DigitalCraftsman\DateTimePrecision\Weekday;
+use DigitalCraftsman\DateTimePrecision\Year;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeBeforeOrEqualToInTimeZoneTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeBeforeOrEqualToInTimeZone
+     */
+    public function must_not_be_before_or_equal_to_in_time_zone_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Time | Weekday | Date | Month | Year $comparator,
+        \DateTimeZone $timeZone,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeBeforeOrEqualToInTimeZone(
+            $comparator,
+            $timeZone,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Time | Weekday | Date | Month | Year,
+     *   3: \DateTimeZone,
+     *   4: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromStringInTimeZone('2022-10-08 16:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('15:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsBeforeOrEqualTo::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('16:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsBeforeOrEqualToInTimeZone::class,
+                Moment::fromStringInTimeZone('2022-10-08 15:00:00', new \DateTimeZone('Europe/Berlin')),
+                Time::fromString('16:00:00'),
+                new \DateTimeZone('Europe/Berlin'),
+                static fn () => new CustomMomentIsBeforeOrEqualToInTimeZone(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Moment/MustNotBeBeforeOrEqualToTest.php b/tests/Moment/MustNotBeBeforeOrEqualToTest.php
new file mode 100644
index 0000000..97681ce
--- /dev/null
+++ b/tests/Moment/MustNotBeBeforeOrEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Moment;
+
+use DigitalCraftsman\DateTimePrecision\Exception\MomentIsBeforeOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Moment;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomMomentIsBeforeOrEqualTo;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Moment */
+final class MustNotBeBeforeOrEqualToTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeBeforeOrEqualTo
+     */
+    public function must_not_be_before_or_equal_to_works(
+        ?string $expectedResult,
+        Moment $moment,
+        Moment $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $moment->mustNotBeBeforeOrEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Moment,
+     *   2: Moment,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 15:00:00'),
+                null,
+            ],
+            'default exception' => [
+                MomentIsBeforeOrEqualTo::class,
+                Moment::fromString('2022-10-08 15:00:00'),
+                Moment::fromString('2022-10-08 16:00:00'),
+                null,
+            ],
+            'custom exception' => [
+                CustomMomentIsBeforeOrEqualTo::class,
+                Moment::fromString('2022-10-08 16:00:00'),
+                Moment::fromString('2022-10-08 17:00:00'),
+                static fn () => new CustomMomentIsBeforeOrEqualTo(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomMomentIsBeforeOrEqualTo.php b/tests/Test/Exception/CustomMomentIsBeforeOrEqualTo.php
new file mode 100644
index 0000000..788b4a0
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsBeforeOrEqualTo.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsBeforeOrEqualTo extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomMomentIsBeforeOrEqualToInTimeZone.php b/tests/Test/Exception/CustomMomentIsBeforeOrEqualToInTimeZone.php
new file mode 100644
index 0000000..beb36f5
--- /dev/null
+++ b/tests/Test/Exception/CustomMomentIsBeforeOrEqualToInTimeZone.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomMomentIsBeforeOrEqualToInTimeZone extends \InvalidArgumentException
+{
+}

From b37ff1732820d718af446c690f094e7d2a2e6b35 Mon Sep 17 00:00:00 2001
From: Christian Kolb <info@digital-craftsman.de>
Date: Sun, 23 Jun 2024 08:37:01 +0200
Subject: [PATCH 14/14] Adapt changelog

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f1734c8..6f9a7af 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,7 @@
 ## 0.11.0
 
 - Added `Clock` implementation with `SystemClock` and `FrozenClock`.
+- Added guard methods for comparison methods to `Moment` like `mustBeEqualTo` with option to throw custom exception.
 
 ## 0.10.0