Merge pull request 'Feature: natuerliche Werte' (#8) from feature/natuerliche-werte into master

Reviewed-on: #8

README.md

@@ -11,6 +11,22 @@ Die Modelle müssen mit den Informationen gefüllt werden. Ein nicht geändertes
 Die Werte sind immer reelle Zahlen von '0.0' bis '1.0'. Dadurch sind die Modele vom eigentlichen Einsatz unabhängig.
 Die Klassen haben keinen Alphakanal.
 
+### Natürliche Modelle
+
+Die Modelle werden auch in der 'natürlichen' Darstellung bereitgestellt.
+
+#### CyanMagentaYellowKey
+
+Alle Werte werden in der Prozent-Schreibweise zur Verfügung gestellt.
+
+#### HueSaturationValue
+
+*Hue* wird als Gradzahl und die anderen Werte als Prozent-Schreibweise zur Verfügung gestellt.
+
+#### RedGreenBlue
+
+Die Werte werden als Hexadecimal Zahlen und in der Webschreibweise zur Verfügung gestellt.
+
 ## Hinweise zu den Transformer-Klassen
 
 Das Vorgehen der Umwandlung nimmt die Informationen von 

resources/uml/Klassen-Aufbau.puml

@@ -0,0 +1,58 @@
+@startuml
+'https://plantuml.com/class-diagram
+
+namespace NaturallyColorModels {
+    class CyanMagentaYellowKey
+    class HueSaturationValue
+    class RedGreenBlue
+}
+
+namespace ColorModels {
+    abstract AbstractColorModel
+    class CyanMagentaYellowKey
+    class HueSaturationValue
+    class RedGreenBlue
+    CyanMagentaYellowKey --|> AbstractColorModel
+    HueSaturationValue --|> AbstractColorModel
+    RedGreenBlue --|> AbstractColorModel
+}
+NaturallyColorModels.CyanMagentaYellowKey o-- ColorModels.CyanMagentaYellowKey
+NaturallyColorModels.HueSaturationValue o-- ColorModels.HueSaturationValue
+NaturallyColorModels.RedGreenBlue o-- ColorModels.RedGreenBlue
+
+
+namespace Transformer {
+    interface ColorModelTransformInterface {
+        + toRedGreenBlue(): RedGreenBlue;
+        + toCyanMagentaYellowKey(): CyanMagentaYellowKey;
+        + toHueSaturationValue(): HueSaturationValue;
+    }
+    class CyanMagentaYellowKeyTransformer
+    class HueSaturationValueTransformer
+    class RedGreenBlueTransformer
+    ColorModelTransformInterface <|-- CyanMagentaYellowKeyTransformer
+    ColorModelTransformInterface <|-- HueSaturationValueTransformer
+    ColorModelTransformInterface <|-- RedGreenBlueTransformer
+    namespace Utilities {
+        abstract AbstractHueSaturationValueToUtility
+        class CyanMagentaYellowKeyToHueSaturationValue
+        class HueSaturationValueToCyanMagentaYellowKey
+        class HueSaturationValueToRedGreenBlue
+        class RedGreenBlueToHueSaturationValue
+        Transformer.Utilities.CyanMagentaYellowKeyToHueSaturationValue --|> Transformer.Utilities.AbstractHueSaturationValueToUtility
+        Transformer.Utilities.HueSaturationValueToCyanMagentaYellowKey --|> Transformer.Utilities.AbstractHueSaturationValueToUtility
+        Transformer.Utilities.HueSaturationValueToRedGreenBlue --|> Transformer.Utilities.AbstractHueSaturationValueToUtility
+        Transformer.Utilities.RedGreenBlueToHueSaturationValue --|> Transformer.Utilities.AbstractHueSaturationValueToUtility
+    }
+    CyanMagentaYellowKeyTransformer o-- Transformer.Utilities.CyanMagentaYellowKeyToHueSaturationValue
+    CyanMagentaYellowKeyTransformer o-- Transformer.Utilities.HueSaturationValueToRedGreenBlue
+
+    HueSaturationValueTransformer o-- Transformer.Utilities.HueSaturationValueToRedGreenBlue
+    HueSaturationValueTransformer o-- Transformer.Utilities.HueSaturationValueToCyanMagentaYellowKey
+
+    RedGreenBlueTransformer o-- Transformer.Utilities.RedGreenBlueToHueSaturationValue
+    RedGreenBlueTransformer o-- Transformer.Utilities.HueSaturationValueToCyanMagentaYellowKey
+}
+ColorModels.AbstractColorModel --o Transformer.ColorModelTransformInterface
+
+@enduml

src/NaturallyColorModels/CyanMagentaYellowKey.php

@@ -0,0 +1,101 @@
+<?php
+
+
+namespace TorstenHettstedt\Colors\NaturallyColorModels;
+
+use JetBrains\PhpStorm\Pure;
+use TorstenHettstedt\Colors\ColorModels\CyanMagentaYellowKey as PureCyanMagentaYellowKey;
+
+/**
+ * Definition des allgemeinen CMYK-Farbraumes. Die Werte für die eigenschaften sind reelle Zahlen von 0 bis einschließlich 1.
+ * Ohne Änderung der Eigenschaften wird die Farbe *weiß* dargestellt.
+ */
+class CyanMagentaYellowKey
+{
+    /** @var PureCyanMagentaYellowKey : Standard-Color-Modell */
+    protected PureCyanMagentaYellowKey $pureColor;
+    protected Helper\PercentValues     $percentValuesHelper;
+
+    #[Pure] public function __construct()
+    {
+        $this->pureColor = new PureCyanMagentaYellowKey();
+        $this->percentValuesHelper = new Helper\PercentValues();
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getCyan(): int
+    {
+        return $this->percentValuesHelper->asPercentValue($this->pureColor->getCyan());
+    }
+
+    /**
+     * @param int $cyan
+     * @return CyanMagentaYellowKey
+     */
+    public function setCyan(int $cyan): CyanMagentaYellowKey
+    {
+        $this->percentValuesHelper->checkPercentValue($cyan);
+        $this->pureColor->setCyan($this->percentValuesHelper->fromPercentValue($cyan));
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getMagenta(): int
+    {
+        return $this->percentValuesHelper->asPercentValue($this->pureColor->getMagenta());
+    }
+
+    /**
+     * @param int $magenta
+     * @return CyanMagentaYellowKey
+     */
+    public function setMagenta(int $magenta): CyanMagentaYellowKey
+    {
+        $this->percentValuesHelper->checkPercentValue($magenta);
+        $this->pureColor->setMagenta($this->percentValuesHelper->fromPercentValue($magenta));
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getYellow(): int
+    {
+        return $this->percentValuesHelper->asPercentValue($this->pureColor->getYellow());
+    }
+
+    /**
+     * @param int $yellow
+     * @return CyanMagentaYellowKey
+     */
+    public function setYellow(int $yellow): CyanMagentaYellowKey
+    {
+        $this->percentValuesHelper->checkPercentValue($yellow);
+        $this->pureColor->setYellow($this->percentValuesHelper->fromPercentValue($yellow));
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getKey(): int
+    {
+        return $this->percentValuesHelper->asPercentValue($this->pureColor->getKey());
+    }
+
+    /**
+     * @param int $key
+     * @return CyanMagentaYellowKey
+     */
+    public function setKey(int $key): CyanMagentaYellowKey
+    {
+        $this->percentValuesHelper->checkPercentValue($key);
+        $this->pureColor->setKey($this->percentValuesHelper->fromPercentValue($key));
+        return $this;
+    }
+
+}

src/NaturallyColorModels/Helper/GradValues.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace TorstenHettstedt\Colors\NaturallyColorModels\Helper;
+
+
+use InvalidArgumentException;
+
+class GradValues
+{
+
+    public function asGradValue(float $value): int
+    {
+        return intval($value * 360);
+    }
+
+    public function fromGradValue(int $value): float
+    {
+        return $value / 360.0;
+    }
+
+    public function checkGradValue(int $value): void
+    {
+        if ($value > 360) {
+            throw new InvalidArgumentException('Ein Wert größer als 360° ist nicht definierbar.');
+        }
+        if ($value < 0) {
+            throw new InvalidArgumentException('Ein Wert kleiner als 0° ist nicht definierbar.');
+        }
+    }
+
+}

src/NaturallyColorModels/Helper/HexadecimalValues.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace TorstenHettstedt\Colors\NaturallyColorModels\Helper;
+
+
+use InvalidArgumentException;
+
+class HexadecimalValues
+{
+
+    public function asHexadecimalValue(float $value): int
+    {
+        return intval($value * 0xFF);
+    }
+
+    public function fromHexadecimalValue(int $value): float
+    {
+        return $value / 0xFF;
+    }
+
+    public function checkHexadecimalValue(int $value): void
+    {
+        if ($value > 0xFF) {
+            throw new InvalidArgumentException('Ein Wert größer als "0xFF" ist nicht definierbar.');
+        }
+        if ($value < 0) {
+            throw new InvalidArgumentException('Ein Wert kleiner als "0x00" ist nicht definierbar.');
+        }
+    }
+
+}

src/NaturallyColorModels/Helper/PercentValues.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace TorstenHettstedt\Colors\NaturallyColorModels\Helper;
+
+
+use InvalidArgumentException;
+
+class PercentValues
+{
+
+    public function asPercentValue(float $value): int
+    {
+        return intval($value * 100);
+    }
+
+    public function fromPercentValue(int $value): float
+    {
+        return $value / 100.0;
+    }
+
+    public function checkPercentValue(int $value): void
+    {
+        if ($value > 100) {
+            throw new InvalidArgumentException('Ein Wert größer als 100% ist nicht definierbar.');
+        }
+        if ($value < 0) {
+            throw new InvalidArgumentException('Ein Wert kleiner als 0% ist nicht definierbar.');
+        }
+    }
+
+}

src/NaturallyColorModels/HueSaturationValue.php

@@ -0,0 +1,86 @@
+<?php
+
+
+namespace TorstenHettstedt\Colors\NaturallyColorModels;
+
+
+use JetBrains\PhpStorm\Pure;
+use TorstenHettstedt\Colors\ColorModels\HueSaturationValue as PureHueSaturationValue;
+
+/**
+ * Definition des allgemeinen HSV-Farbraumes. Die Werte für die Eigenschaften sind reelle Zahlen von 0 bis einschließlich 1.
+ * Ohne Änderung der Eigenschaften wird die Farbe *weiß* dargestellt.
+ */
+class HueSaturationValue
+{
+    /** @var PureHueSaturationValue : Standard-Color-Modell */
+    protected PureHueSaturationValue $pureColor;
+    protected Helper\PercentValues $percentValuesHelper;
+    protected Helper\GradValues    $gradValuesHelper;
+
+    #[Pure] public function __construct()
+    {
+        $this->pureColor = new PureHueSaturationValue();
+        $this->percentValuesHelper = new Helper\PercentValues();
+        $this->gradValuesHelper = new Helper\GradValues();
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getHue(): int
+    {
+        return $this->gradValuesHelper->asGradValue($this->pureColor->getHue());
+    }
+
+    /**
+     * @param int $hue
+     * @return HueSaturationValue
+     */
+    public function setHue(int $hue): HueSaturationValue
+    {
+        $this->gradValuesHelper->checkGradValue($hue);
+        $this->pureColor->setHue($this->gradValuesHelper->fromGradValue($hue));
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getSaturation(): int
+    {
+        return $this->percentValuesHelper->asPercentValue($this->pureColor->getSaturation());
+    }
+
+    /**
+     * @param int $saturation
+     * @return HueSaturationValue
+     */
+    public function setSaturation(int $saturation): HueSaturationValue
+    {
+        $this->percentValuesHelper->checkPercentValue($saturation);
+        $this->pureColor->setSaturation($this->percentValuesHelper->fromPercentValue($saturation));
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getValue(): int
+    {
+        return $this->percentValuesHelper->asPercentValue($this->pureColor->getValue());
+    }
+
+    /**
+     * @param int $value
+     * @return HueSaturationValue
+     */
+    public function setValue(int $value): HueSaturationValue
+    {
+        $this->percentValuesHelper->checkPercentValue($value);
+        $this->pureColor->setValue($this->percentValuesHelper->fromPercentValue($value));
+        return $this;
+    }
+
+
+}

src/NaturallyColorModels/RedGreenBlue.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace TorstenHettstedt\Colors\NaturallyColorModels;
+
+use JetBrains\PhpStorm\Pure;
+use TorstenHettstedt\Colors\ColorModels\RedGreenBlue as PureRedGreenBlue;
+
+/**
+ * Definition des allgemeinen RGB-Farbraumes. Die Werte für die eigenschaften sind reelle Zahlen von 0 bis einschließlich 1.
+ * Ohne Änderung der Eigenschaften wird die Farbe *weiß* dargestellt.
+ */
+class RedGreenBlue
+{
+    /** @var PureRedGreenBlue : Standard-Color-Modell */
+    protected PureRedGreenBlue         $pureColor;
+    protected Helper\HexadecimalValues $hexadecimalValuesHelper;
+
+    #[Pure] public function __construct()
+    {
+        $this->pureColor = new PureRedGreenBlue();
+        $this->hexadecimalValuesHelper = new Helper\HexadecimalValues();
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getRed(): int
+    {
+        return $this->hexadecimalValuesHelper->asHexadecimalValue($this->pureColor->getRed());
+    }
+
+    /**
+     * @param int $red
+     * @return RedGreenBlue
+     */
+    public function setRed(int $red): RedGreenBlue
+    {
+        $this->hexadecimalValuesHelper->checkHexadecimalValue($red);
+        $this->pureColor->setRed($this->hexadecimalValuesHelper->fromHexadecimalValue($red));
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    #[Pure] public function getGreen(): int
+    {
+        return $this->hexadecimalValuesHelper->asHexadecimalValue($this->pureColor->getGreen());
+    }
+
+    /**
+     * @param int $green
+     * @return RedGreenBlue
+     */
+    public function setGreen(int $green): RedGreenBlue
+    {
+        $this->hexadecimalValuesHelper->checkHexadecimalValue($green);
+        $this->pureColor->setGreen($this->hexadecimalValuesHelper->fromHexadecimalValue($green));
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    public function getBlue(): int
+    {
+        return $this->hexadecimalValuesHelper->asHexadecimalValue($this->pureColor->getBlue());
+    }
+
+    /**
+     * @param int $blue
+     * @return RedGreenBlue
+     */
+    public function setBlue(int $blue): RedGreenBlue
+    {
+        $this->hexadecimalValuesHelper->checkHexadecimalValue($blue);
+        $this->pureColor->setBlue($this->hexadecimalValuesHelper->fromHexadecimalValue($blue));
+        return $this;
+    }
+
+    public function asHtmlNotation(): string
+    {
+        return sprintf('#%X%X%X', $this->getRed(), $this->getGreen(), $this->getBlue());
+    }
+
+}

tests/unit/NaturallyColorModels/AbstractColorModelUnit.php

@@ -0,0 +1,82 @@
+<?php /** @noinspection PhpArrayShapeAttributeCanBeAddedInspection */
+
+
+namespace TorstenHettstedt\Colors\Tests\Unit\NaturallyColorModels;
+
+use Codeception\Test\Unit;
+
+abstract class AbstractColorModelUnit extends Unit
+{
+
+    abstract public function testConstruct(): void;
+
+    /**
+     * @return int[][]
+     */
+    public function invalidPercentValueProvider(): array
+    {
+        return [
+            'zu klein' => [-1],
+            'zu gross' => [101],
+        ];
+    }
+
+    /**
+     * @return int[][]
+     */
+    public function validPercentValueProvider(): array
+    {
+        return [
+            'niedrigster Wert' => [0],
+            'mittlerer Wert' => [45],
+            'maximaler Wert' => [100],
+        ];
+    }
+
+    /**
+     * @return int[][]
+     */
+    public function invalidGradValueProvider(): array
+    {
+        return [
+            'zu klein' => [-1],
+            'zu gross' => [361],
+        ];
+    }
+
+    /**
+     * @return int[][]
+     */
+    public function validGradValueProvider(): array
+    {
+        return [
+            'niedrigster Wert' => [0],
+            'mittlerer Wert' => [45],
+            'maximaler Wert' => [360],
+        ];
+    }
+
+    /**
+     * @return int[][]
+     */
+    public function invalidHexadecimalValueProvider(): array
+    {
+        return [
+            'zu klein' => [-0x1],
+            'zu gross' => [0x100],
+        ];
+    }
+
+    /**
+     * @return int[][]
+     */
+    public function validHexadecimalValueProvider(): array
+    {
+        return [
+            'niedrigster Wert' => [0x0],
+            'mittlerer Wert' => [0xD9],
+            'maximaler Wert' => [0xFF],
+        ];
+    }
+
+}

tests/unit/NaturallyColorModels/CyanMagentaYellowKeyTest.php

@@ -0,0 +1,128 @@
+<?php
+
+namespace TorstenHettstedt\Colors\Tests\Unit\NaturallyColorModels;
+
+use InvalidArgumentException;
+use TorstenHettstedt\Colors\NaturallyColorModels\CyanMagentaYellowKey;
+
+class CyanMagentaYellowKeyTest extends AbstractColorModelUnit
+{
+
+    public function testConstruct(): void
+    {
+        $color = new CyanMagentaYellowKey();
+
+        $this->assertIsInt($color->getCyan());
+        $this->assertEquals(0, $color->getCyan());
+        $this->assertIsInt($color->getMagenta());
+        $this->assertEquals(0, $color->getMagenta());
+        $this->assertIsInt($color->getCyan());
+        $this->assertEquals(0, $color->getYellow());
+        $this->assertIsInt($color->getKey());
+        $this->assertEquals(0, $color->getKey());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider validPercentValueProvider
+     */
+    public function testSetCyanWithValidValue(int $value): void
+    {
+        $color = new CyanMagentaYellowKey();
+
+        $color->setCyan($value);
+        $this->assertEquals($value, $color->getCyan());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider validPercentValueProvider
+     */
+    public function testSetMagentaWithValidValue(int $value): void
+    {
+        $color = new CyanMagentaYellowKey();
+
+        $color->setMagenta($value);
+        $this->assertEquals($value, $color->getMagenta());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider validPercentValueProvider
+     */
+    public function testSetYellowWithValidValue(int $value): void
+    {
+        $color = new CyanMagentaYellowKey();
+
+        $color->setYellow($value);
+        $this->assertEquals($value, $color->getYellow());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider validPercentValueProvider
+     */
+    public function testSetKeyWithValidValue(int $value): void
+    {
+        $color = new CyanMagentaYellowKey();
+
+        $color->setKey($value);
+        $this->assertEquals($value, $color->getKey());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidPercentValueProvider
+     */
+    public function testSetCyanWithInvalidValue(int $value): void
+    {
+        $color = new CyanMagentaYellowKey();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setCyan($value);
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidPercentValueProvider
+     */
+    public function testSetMagentaWithInvalidValue(int $value): void
+    {
+        $color = new CyanMagentaYellowKey();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setMagenta($value);
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidPercentValueProvider
+     */
+    public function testSetYellowWithInvalidValue(int $value): void
+    {
+        $color = new CyanMagentaYellowKey();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setYellow($value);
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidPercentValueProvider
+     */
+    public function testSetKeyWithInvalidValue(int $value): void
+    {
+        $color = new CyanMagentaYellowKey();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setKey($value);
+    }
+}

tests/unit/NaturallyColorModels/HueSaturationValueTest.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace TorstenHettstedt\Colors\Tests\Unit\NaturallyColorModels;
+
+use InvalidArgumentException;
+use TorstenHettstedt\Colors\NaturallyColorModels\HueSaturationValue;
+
+class HueSaturationValueTest extends AbstractColorModelUnit
+{
+
+    public function testConstruct(): void
+    {
+        $color = new HueSaturationValue();
+
+        $this->assertIsInt($color->getHue());
+        $this->assertEquals(0, $color->getHue());
+        $this->assertIsInt($color->getSaturation());
+        $this->assertEquals(0, $color->getSaturation());
+        $this->assertIsInt($color->getValue());
+        $this->assertEquals(100, $color->getValue());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider validGradValueProvider
+     */
+    public function testSetHueWithValidValue(int $value): void
+    {
+        $color = new HueSaturationValue();
+
+        $color->setHue($value);
+        $this->assertEquals($value, $color->getHue());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidGradValueProvider
+     */
+    public function testSetHueWithInvalidValue(int $value): void
+    {
+        $color = new HueSaturationValue();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setHue($value);
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider validPercentValueProvider
+     */
+    public function testSetSaturationWithValidValue(int $value): void
+    {
+        $color = new HueSaturationValue();
+
+        $color->setSaturation($value);
+        $this->assertEquals($value, $color->getSaturation());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidPercentValueProvider
+     */
+    public function testSetSaturationWithInvalidValue(int $value): void
+    {
+        $color = new HueSaturationValue();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setSaturation($value);
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider validPercentValueProvider
+     */
+    public function testSetValueWithValidValue(int $value): void
+    {
+        $color = new HueSaturationValue();
+
+        $color->setValue($value);
+        $this->assertEquals($value, $color->getValue());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidPercentValueProvider
+     */
+    public function testSetValueWithInvalidValue(int $value): void
+    {
+        $color = new HueSaturationValue();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setValue($value);
+    }
+}

tests/unit/NaturallyColorModels/RedGreenBlueTest.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace TorstenHettstedt\Colors\Tests\Unit\NaturallyColorModels;
+
+use InvalidArgumentException;
+use TorstenHettstedt\Colors\NaturallyColorModels\RedGreenBlue;
+
+class RedGreenBlueTest extends AbstractColorModelUnit
+{
+
+    public function testConstruct(): void
+    {
+        $color = new RedGreenBlue();
+
+        $this->assertEquals(0xFF, $color->getRed());
+        $this->assertEquals(0xFF, $color->getGreen());
+        $this->assertEquals(0xFF, $color->getBlue());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider validHexadecimalValueProvider
+     */
+    public function testSetRedWithValidValue(int $value): void
+    {
+        $color = new RedGreenBlue();
+
+        $color->setRed($value);
+        $this->assertEquals($value, $color->getRed());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidHexadecimalValueProvider
+     */
+    public function testSetRedWithInvalidValue(int $value): void
+    {
+        $color = new RedGreenBlue();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setRed($value);
+    }
+    /**
+     * @param int $value
+     *
+     * @dataProvider validHexadecimalValueProvider
+     */
+    public function testSetGreenWithValidValue(int $value): void
+    {
+        $color = new RedGreenBlue();
+
+        $color->setGreen($value);
+        $this->assertEquals($value, $color->getGreen());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidHexadecimalValueProvider
+     */
+    public function testSetGreenWithInvalidValue(int $value): void
+    {
+        $color = new RedGreenBlue();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setGreen($value);
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider validHexadecimalValueProvider
+     */
+    public function testSetBlueWithValidValue(int $value): void
+    {
+        $color = new RedGreenBlue();
+
+        $color->setBlue($value);
+        $this->assertEquals($value, $color->getBlue());
+    }
+
+    /**
+     * @param int $value
+     *
+     * @dataProvider invalidHexadecimalValueProvider
+     */
+    public function testSetBlueWithInvalidValue(int $value): void
+    {
+        $color = new RedGreenBlue();
+
+        $this->expectException(InvalidArgumentException::class);
+        $color->setBlue($value);
+    }
+
+    public function testHtmlNotation(): void
+    {
+        $color = new RedGreenBlue();
+        $color->setRed(0xA1);
+        $color->setGreen(0xB2);
+        $color->setBlue(0xC3);
+
+        $html = $color->asHtmlNotation();
+
+        $this->assertIsString($html);
+        $this->assertEquals('#A1B2C3', $html);
+    }
+}