diff --git a/CHANGELOG.md b/CHANGELOG.md
index 65e6a72..bfe3338 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@
 
 - **[Breaking change](./UPGRADE.md#removed-deprecated-isdate-methods-from-moment)**: Removed deprecated `isDate*` methods from `Moment`.
 - Added `Clock` implementation with `SystemClock` and `FrozenClock`.
-- Added guard methods for comparison methods to `Moment` like `mustBeEqualTo` with option to throw custom exception.
+- Added guard methods for comparison methods to `Moment` and `Date` like `mustBeEqualTo` with option to throw custom exception.
 
 ## 0.10.0
 
diff --git a/src/Date.php b/src/Date.php
index 4219ccb..bfaeb08 100644
--- a/src/Date.php
+++ b/src/Date.php
@@ -49,14 +49,14 @@ public static function fromString(string $date): self
         }
     }
 
-    // Stringable
+    // -- Stringable
 
     public function __toString(): string
     {
         return $this->format(self::DATE_FORMAT);
     }
 
-    // Accessors
+    // -- Accessors
 
     public function isEqualTo(self $date): bool
     {
@@ -156,7 +156,179 @@ public function weekday(): Weekday
         return Weekday::fromDateTime($this->toDateTimeImmutable());
     }
 
-    // Mutations
+    // -- Guards
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsNotEqual
+     */
+    public function mustBeEqualTo(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotEqualTo($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsNotEqual();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsEqual
+     */
+    public function mustNotBeEqualTo(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isEqualTo($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsEqual();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsNotAfter
+     */
+    public function mustBeAfter(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotAfter($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsNotAfter();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsAfter
+     */
+    public function mustNotBeAfter(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isAfter($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsAfter();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsNotAfterOrEqualTo
+     */
+    public function mustBeAfterOrEqualTo(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotAfterOrEqualTo($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsNotAfterOrEqualTo();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsAfterOrEqualTo
+     */
+    public function mustNotBeAfterOrEqualTo(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isAfterOrEqualTo($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsAfterOrEqualTo();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsNotBefore
+     */
+    public function mustBeBefore(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotBefore($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsNotBefore();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsBefore
+     */
+    public function mustNotBeBefore(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isBefore($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsBefore();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsNotBeforeOrEqualTo
+     */
+    public function mustBeBeforeOrEqualTo(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isNotBeforeOrEqualTo($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsNotBeforeOrEqualTo();
+        }
+    }
+
+    /**
+     * @param ?callable(): \Throwable $otherwiseThrow
+     *
+     * @throws \Throwable
+     * @throws Exception\DateIsBeforeOrEqualTo
+     */
+    public function mustNotBeBeforeOrEqualTo(
+        self $date,
+        ?callable $otherwiseThrow = null,
+    ): void {
+        if ($this->isBeforeOrEqualTo($date)) {
+            throw $otherwiseThrow !== null
+                ? $otherwiseThrow()
+                : new Exception\DateIsBeforeOrEqualTo();
+        }
+    }
+
+    // -- Mutations
 
     public function format(string $format): string
     {
diff --git a/src/Exception/DateIsAfter.php b/src/Exception/DateIsAfter.php
new file mode 100644
index 0000000..0915f0c
--- /dev/null
+++ b/src/Exception/DateIsAfter.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsAfter extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is after but must not be.');
+    }
+}
diff --git a/src/Exception/DateIsAfterOrEqualTo.php b/src/Exception/DateIsAfterOrEqualTo.php
new file mode 100644
index 0000000..721b9f8
--- /dev/null
+++ b/src/Exception/DateIsAfterOrEqualTo.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsAfterOrEqualTo extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is after or equal to but must not be.');
+    }
+}
diff --git a/src/Exception/DateIsBefore.php b/src/Exception/DateIsBefore.php
new file mode 100644
index 0000000..060eff4
--- /dev/null
+++ b/src/Exception/DateIsBefore.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsBefore extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is before but must not be.');
+    }
+}
diff --git a/src/Exception/DateIsBeforeOrEqualTo.php b/src/Exception/DateIsBeforeOrEqualTo.php
new file mode 100644
index 0000000..436380d
--- /dev/null
+++ b/src/Exception/DateIsBeforeOrEqualTo.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsBeforeOrEqualTo extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is before or equal to but must not be.');
+    }
+}
diff --git a/src/Exception/DateIsEqual.php b/src/Exception/DateIsEqual.php
new file mode 100644
index 0000000..bc73273
--- /dev/null
+++ b/src/Exception/DateIsEqual.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsEqual extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is equal but must not be.');
+    }
+}
diff --git a/src/Exception/DateIsNotAfter.php b/src/Exception/DateIsNotAfter.php
new file mode 100644
index 0000000..2d4da03
--- /dev/null
+++ b/src/Exception/DateIsNotAfter.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsNotAfter extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is not after but must be.');
+    }
+}
diff --git a/src/Exception/DateIsNotAfterOrEqualTo.php b/src/Exception/DateIsNotAfterOrEqualTo.php
new file mode 100644
index 0000000..2c3a6e6
--- /dev/null
+++ b/src/Exception/DateIsNotAfterOrEqualTo.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsNotAfterOrEqualTo extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is not after or equal to but must be.');
+    }
+}
diff --git a/src/Exception/DateIsNotBefore.php b/src/Exception/DateIsNotBefore.php
new file mode 100644
index 0000000..c920c92
--- /dev/null
+++ b/src/Exception/DateIsNotBefore.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsNotBefore extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is not before but must be.');
+    }
+}
diff --git a/src/Exception/DateIsNotBeforeOrEqualTo.php b/src/Exception/DateIsNotBeforeOrEqualTo.php
new file mode 100644
index 0000000..9413bd5
--- /dev/null
+++ b/src/Exception/DateIsNotBeforeOrEqualTo.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsNotBeforeOrEqualTo extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is not before or equal to but must be.');
+    }
+}
diff --git a/src/Exception/DateIsNotEqual.php b/src/Exception/DateIsNotEqual.php
new file mode 100644
index 0000000..7e5b857
--- /dev/null
+++ b/src/Exception/DateIsNotEqual.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Exception;
+
+/**
+ * @psalm-immutable
+ *
+ * @codeCoverageIgnore
+ */
+final class DateIsNotEqual extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct('The date is not equal but must be.');
+    }
+}
diff --git a/tests/Date/MustBeAfterOrEqualToTest.php b/tests/Date/MustBeAfterOrEqualToTest.php
new file mode 100644
index 0000000..e2308d1
--- /dev/null
+++ b/tests/Date/MustBeAfterOrEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsNotAfterOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsNotAfterOrEqualTo;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+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,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustBeAfterOrEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'default exception' => [
+                DateIsNotAfterOrEqualTo::class,
+                Date::fromString('2022-10-07'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsNotAfterOrEqualTo::class,
+                Date::fromString('2022-10-07'),
+                Date::fromString('2022-10-08'),
+                static fn () => new CustomDateIsNotAfterOrEqualTo(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Date/MustBeAfterTest.php b/tests/Date/MustBeAfterTest.php
new file mode 100644
index 0000000..32c9b13
--- /dev/null
+++ b/tests/Date/MustBeAfterTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsNotAfter;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsNotAfter;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+final class MustBeAfterTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeAfter
+     */
+    public function must_be_after_works(
+        ?string $expectedResult,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustBeAfter(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-09'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'default exception' => [
+                DateIsNotAfter::class,
+                Date::fromString('2022-10-07'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsNotAfter::class,
+                Date::fromString('2022-10-07'),
+                Date::fromString('2022-10-08'),
+                static fn () => new CustomDateIsNotAfter(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Date/MustBeBeforeOrEqualToTest.php b/tests/Date/MustBeBeforeOrEqualToTest.php
new file mode 100644
index 0000000..55845c1
--- /dev/null
+++ b/tests/Date/MustBeBeforeOrEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsNotBeforeOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsNotBeforeOrEqualTo;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+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,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustBeBeforeOrEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-09'),
+                null,
+            ],
+            'default exception' => [
+                DateIsNotBeforeOrEqualTo::class,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-07'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsNotBeforeOrEqualTo::class,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-07'),
+                static fn () => new CustomDateIsNotBeforeOrEqualTo(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Date/MustBeBeforeTest.php b/tests/Date/MustBeBeforeTest.php
new file mode 100644
index 0000000..bfc2dea
--- /dev/null
+++ b/tests/Date/MustBeBeforeTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsNotBefore;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsNotBefore;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+final class MustBeBeforeTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeBefore
+     */
+    public function must_be_before_works(
+        ?string $expectedResult,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustBeBefore(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-09'),
+                null,
+            ],
+            'default exception' => [
+                DateIsNotBefore::class,
+                Date::fromString('2022-10-09'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsNotBefore::class,
+                Date::fromString('2022-10-09'),
+                Date::fromString('2022-10-08'),
+                static fn () => new CustomDateIsNotBefore(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Date/MustBeEqualToTest.php b/tests/Date/MustBeEqualToTest.php
new file mode 100644
index 0000000..9b8d279
--- /dev/null
+++ b/tests/Date/MustBeEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsNotEqual;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsNotEqual;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+final class MustBeEqualToTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustBeEqualTo
+     */
+    public function must_be_equal_to_works(
+        ?string $expectedResult,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustBeEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'default exception' => [
+                DateIsNotEqual::class,
+                Date::fromString('2022-10-07'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsNotEqual::class,
+                Date::fromString('2022-10-07'),
+                Date::fromString('2022-10-08'),
+                static fn () => new CustomDateIsNotEqual(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Date/MustNotBeAfterOrEqualToTest.php b/tests/Date/MustNotBeAfterOrEqualToTest.php
new file mode 100644
index 0000000..bbf5f03
--- /dev/null
+++ b/tests/Date/MustNotBeAfterOrEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsAfterOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsAfterOrEqualTo;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+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,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustNotBeAfterOrEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-09'),
+                null,
+            ],
+            'default exception' => [
+                DateIsAfterOrEqualTo::class,
+                Date::fromString('2022-10-09'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsAfterOrEqualTo::class,
+                Date::fromString('2022-10-09'),
+                Date::fromString('2022-10-08'),
+                static fn () => new CustomDateIsAfterOrEqualTo(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Date/MustNotBeAfterTest.php b/tests/Date/MustNotBeAfterTest.php
new file mode 100644
index 0000000..ddd5970
--- /dev/null
+++ b/tests/Date/MustNotBeAfterTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsAfter;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsAfter;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+final class MustNotBeAfterTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeAfter
+     */
+    public function must_not_be_after_works(
+        ?string $expectedResult,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustNotBeAfter(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-09'),
+                null,
+            ],
+            'default exception' => [
+                DateIsAfter::class,
+                Date::fromString('2022-10-09'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsAfter::class,
+                Date::fromString('2022-10-09'),
+                Date::fromString('2022-10-08'),
+                static fn () => new CustomDateIsAfter(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Date/MustNotBeBeforeOrEqualToTest.php b/tests/Date/MustNotBeBeforeOrEqualToTest.php
new file mode 100644
index 0000000..a5db78c
--- /dev/null
+++ b/tests/Date/MustNotBeBeforeOrEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsBeforeOrEqualTo;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsBeforeOrEqualTo;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+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,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustNotBeBeforeOrEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-09'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'default exception' => [
+                DateIsBeforeOrEqualTo::class,
+                Date::fromString('2022-10-07'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsBeforeOrEqualTo::class,
+                Date::fromString('2022-10-07'),
+                Date::fromString('2022-10-08'),
+                static fn () => new CustomDateIsBeforeOrEqualTo(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Date/MustNotBeBeforeTest.php b/tests/Date/MustNotBeBeforeTest.php
new file mode 100644
index 0000000..064cb16
--- /dev/null
+++ b/tests/Date/MustNotBeBeforeTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsBefore;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsBefore;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+final class MustNotBeBeforeTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @param ?class-string<\Throwable> $expectedResult
+     *
+     * @dataProvider dataProvider
+     *
+     * @covers ::mustNotBeBefore
+     */
+    public function must_not_be_before_works(
+        ?string $expectedResult,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustNotBeBefore(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-09'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'default exception' => [
+                DateIsBefore::class,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-09'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsBefore::class,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-09'),
+                static fn () => new CustomDateIsBefore(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Date/MustNotBeEqualToTest.php b/tests/Date/MustNotBeEqualToTest.php
new file mode 100644
index 0000000..8cf3073
--- /dev/null
+++ b/tests/Date/MustNotBeEqualToTest.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Date;
+
+use DigitalCraftsman\DateTimePrecision\Date;
+use DigitalCraftsman\DateTimePrecision\Exception\DateIsEqual;
+use DigitalCraftsman\DateTimePrecision\Test\Exception\CustomDateIsEqual;
+use PHPUnit\Framework\TestCase;
+
+/** @coversDefaultClass \DigitalCraftsman\DateTimePrecision\Date */
+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,
+        Date $date,
+        Date $comparator,
+        ?callable $otherwiseThrow,
+    ): void {
+        // -- Act & Assert
+        if ($expectedResult !== null) {
+            $this->expectException($expectedResult);
+        } else {
+            $this->expectNotToPerformAssertions();
+        }
+
+        $date->mustNotBeEqualTo(
+            $comparator,
+            $otherwiseThrow,
+        );
+    }
+
+    /**
+     * @return array<string, array{
+     *   0: ?string,
+     *   1: Date,
+     *   2: Date,
+     *   3: ?callable(): \Throwable
+     * }>
+     */
+    public static function dataProvider(): array
+    {
+        return [
+            'without exception' => [
+                null,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-09'),
+                null,
+            ],
+            'default exception' => [
+                DateIsEqual::class,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-08'),
+                null,
+            ],
+            'custom exception' => [
+                CustomDateIsEqual::class,
+                Date::fromString('2022-10-08'),
+                Date::fromString('2022-10-08'),
+                static fn () => new CustomDateIsEqual(),
+            ],
+        ];
+    }
+}
diff --git a/tests/Test/Exception/CustomDateIsAfter.php b/tests/Test/Exception/CustomDateIsAfter.php
new file mode 100644
index 0000000..b3bf30c
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsAfter.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsAfter extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomDateIsAfterOrEqualTo.php b/tests/Test/Exception/CustomDateIsAfterOrEqualTo.php
new file mode 100644
index 0000000..3952593
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsAfterOrEqualTo.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsAfterOrEqualTo extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomDateIsBefore.php b/tests/Test/Exception/CustomDateIsBefore.php
new file mode 100644
index 0000000..e9555b5
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsBefore.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsBefore extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomDateIsBeforeOrEqualTo.php b/tests/Test/Exception/CustomDateIsBeforeOrEqualTo.php
new file mode 100644
index 0000000..b5e328d
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsBeforeOrEqualTo.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsBeforeOrEqualTo extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomDateIsEqual.php b/tests/Test/Exception/CustomDateIsEqual.php
new file mode 100644
index 0000000..0009e85
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsEqual.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsEqual extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomDateIsNotAfter.php b/tests/Test/Exception/CustomDateIsNotAfter.php
new file mode 100644
index 0000000..3e3e14e
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsNotAfter.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsNotAfter extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomDateIsNotAfterOrEqualTo.php b/tests/Test/Exception/CustomDateIsNotAfterOrEqualTo.php
new file mode 100644
index 0000000..e7c8db3
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsNotAfterOrEqualTo.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsNotAfterOrEqualTo extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomDateIsNotBefore.php b/tests/Test/Exception/CustomDateIsNotBefore.php
new file mode 100644
index 0000000..ccb2f10
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsNotBefore.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsNotBefore extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomDateIsNotBeforeOrEqualTo.php b/tests/Test/Exception/CustomDateIsNotBeforeOrEqualTo.php
new file mode 100644
index 0000000..faa3fba
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsNotBeforeOrEqualTo.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsNotBeforeOrEqualTo extends \InvalidArgumentException
+{
+}
diff --git a/tests/Test/Exception/CustomDateIsNotEqual.php b/tests/Test/Exception/CustomDateIsNotEqual.php
new file mode 100644
index 0000000..6bf4f1b
--- /dev/null
+++ b/tests/Test/Exception/CustomDateIsNotEqual.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DigitalCraftsman\DateTimePrecision\Test\Exception;
+
+final class CustomDateIsNotEqual extends \InvalidArgumentException
+{
+}