tez-utils-enum/tests/ComparableTraitTest.php

<?php

declare(strict_types=1);

namespace Tez\Utils\Tests\Enum;

use PHPUnit\Framework\TestCase;
use Tez\Utils\Enum\BackedEnumTrait;
use Tez\Utils\Enum\ComparableTrait;

enum Level: int
{
    use BackedEnumTrait;
    use ComparableTrait;

    case Low    = 1;
    case Medium = 2;
    case High   = 3;
    case Ultra  = 4;
}

final class ComparableTraitTest extends TestCase
{
    // -------------------------------------------------------------------------
    // isGreaterThan()
    // -------------------------------------------------------------------------

    public function testIsGreaterThanReturnsTrueWhenHigher(): void
    {
        self::assertTrue(Level::High->isGreaterThan(Level::Low));
    }

    public function testIsGreaterThanReturnsFalseWhenEqual(): void
    {
        self::assertFalse(Level::Medium->isGreaterThan(Level::Medium));
    }

    public function testIsGreaterThanReturnsFalseWhenLower(): void
    {
        self::assertFalse(Level::Low->isGreaterThan(Level::High));
    }

    // -------------------------------------------------------------------------
    // isGreaterThanOrEqual()
    // -------------------------------------------------------------------------

    public function testIsGreaterThanOrEqualReturnsTrueWhenHigher(): void
    {
        self::assertTrue(Level::High->isGreaterThanOrEqual(Level::Low));
    }

    public function testIsGreaterThanOrEqualReturnsTrueWhenEqual(): void
    {
        self::assertTrue(Level::Medium->isGreaterThanOrEqual(Level::Medium));
    }

    public function testIsGreaterThanOrEqualReturnsFalseWhenLower(): void
    {
        self::assertFalse(Level::Low->isGreaterThanOrEqual(Level::High));
    }

    // -------------------------------------------------------------------------
    // isLessThan()
    // -------------------------------------------------------------------------

    public function testIsLessThanReturnsTrueWhenLower(): void
    {
        self::assertTrue(Level::Low->isLessThan(Level::High));
    }

    public function testIsLessThanReturnsFalseWhenEqual(): void
    {
        self::assertFalse(Level::Medium->isLessThan(Level::Medium));
    }

    public function testIsLessThanReturnsFalseWhenHigher(): void
    {
        self::assertFalse(Level::High->isLessThan(Level::Low));
    }

    // -------------------------------------------------------------------------
    // isLessThanOrEqual()
    // -------------------------------------------------------------------------

    public function testIsLessThanOrEqualReturnsTrueWhenLower(): void
    {
        self::assertTrue(Level::Low->isLessThanOrEqual(Level::High));
    }

    public function testIsLessThanOrEqualReturnsTrueWhenEqual(): void
    {
        self::assertTrue(Level::Medium->isLessThanOrEqual(Level::Medium));
    }

    public function testIsLessThanOrEqualReturnsFalseWhenHigher(): void
    {
        self::assertFalse(Level::High->isLessThanOrEqual(Level::Low));
    }

    // -------------------------------------------------------------------------
    // between()
    // -------------------------------------------------------------------------

    public function testBetweenReturnsTrueWhenWithinRange(): void
    {
        self::assertTrue(Level::Medium->between(Level::Low, Level::High));
    }

    public function testBetweenReturnsTrueAtLowerBound(): void
    {
        self::assertTrue(Level::Low->between(Level::Low, Level::High));
    }

    public function testBetweenReturnsTrueAtUpperBound(): void
    {
        self::assertTrue(Level::High->between(Level::Low, Level::High));
    }

    public function testBetweenReturnsFalseWhenBelowRange(): void
    {
        self::assertFalse(Level::Low->between(Level::Medium, Level::Ultra));
    }

    public function testBetweenReturnsFalseWhenAboveRange(): void
    {
        self::assertFalse(Level::Ultra->between(Level::Low, Level::High));
    }

    // -------------------------------------------------------------------------
    // clamp()
    // -------------------------------------------------------------------------

    public function testClampReturnsValueWhenWithinRange(): void
    {
        self::assertSame(Level::Medium, Level::Medium->clamp(Level::Low, Level::High));
    }

    public function testClampReturnsMinWhenBelowRange(): void
    {
        self::assertSame(Level::Medium, Level::Low->clamp(Level::Medium, Level::Ultra));
    }

    public function testClampReturnsMaxWhenAboveRange(): void
    {
        self::assertSame(Level::High, Level::Ultra->clamp(Level::Low, Level::High));
    }

    public function testClampReturnsMinWhenEqualToMin(): void
    {
        self::assertSame(Level::Low, Level::Low->clamp(Level::Low, Level::High));
    }

    public function testClampReturnsMaxWhenEqualToMax(): void
    {
        self::assertSame(Level::High, Level::High->clamp(Level::Low, Level::High));
    }
}