From 2cb4bbdc835a0b95626ecb466dc15fda93f3dd1b Mon Sep 17 00:00:00 2001 From: Darth Affe Date: Sun, 24 Feb 2019 11:50:30 +0100 Subject: [PATCH] Added tests for colors --- RGB.NET.sln | 9 + Tests/RGB.NET.Core.Tests/Color/ColorTest.cs | 395 ++++++++++++++ .../RGB.NET.Core.Tests/Color/HSVColorTest.cs | 308 +++++++++++ .../RGB.NET.Core.Tests/Color/RGBColorTest.cs | 504 ++++++++++++++++++ .../RGB.NET.Core.Tests.csproj | 19 + 5 files changed, 1235 insertions(+) create mode 100644 Tests/RGB.NET.Core.Tests/Color/ColorTest.cs create mode 100644 Tests/RGB.NET.Core.Tests/Color/HSVColorTest.cs create mode 100644 Tests/RGB.NET.Core.Tests/Color/RGBColorTest.cs create mode 100644 Tests/RGB.NET.Core.Tests/RGB.NET.Core.Tests.csproj diff --git a/RGB.NET.sln b/RGB.NET.sln index b6ea9d4..9898c32 100644 --- a/RGB.NET.sln +++ b/RGB.NET.sln @@ -39,6 +39,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RGB.NET.Groups", "RGB.NET.G EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RGB.NET.Devices.WS281X", "RGB.NET.Devices.WS281X\RGB.NET.Devices.WS281X.csproj", "{0AD382DA-E999-4F74-9658-8D402EE9BF3F}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{92D7C263-D4C9-4D26-93E2-93C1F9C2CD16}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RGB.NET.Core.Tests", "Tests\RGB.NET.Core.Tests\RGB.NET.Core.Tests.csproj", "{A3FD5AD7-040A-47CA-A278-53493A25FF8A}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -109,6 +113,10 @@ Global {0AD382DA-E999-4F74-9658-8D402EE9BF3F}.Debug|Any CPU.Build.0 = Debug|Any CPU {0AD382DA-E999-4F74-9658-8D402EE9BF3F}.Release|Any CPU.ActiveCfg = Release|Any CPU {0AD382DA-E999-4F74-9658-8D402EE9BF3F}.Release|Any CPU.Build.0 = Release|Any CPU + {A3FD5AD7-040A-47CA-A278-53493A25FF8A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A3FD5AD7-040A-47CA-A278-53493A25FF8A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A3FD5AD7-040A-47CA-A278-53493A25FF8A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A3FD5AD7-040A-47CA-A278-53493A25FF8A}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -129,6 +137,7 @@ Global {8725C448-818C-41F7-B23F-F97E062BF233} = {EBC33090-8494-4DF4-B4B6-64D0E531E93F} {6FEBDC9E-909D-4EE2-B003-EDFBEF5FFF40} = {EBC33090-8494-4DF4-B4B6-64D0E531E93F} {0AD382DA-E999-4F74-9658-8D402EE9BF3F} = {D13032C6-432E-4F43-8A32-071133C22B16} + {A3FD5AD7-040A-47CA-A278-53493A25FF8A} = {92D7C263-D4C9-4D26-93E2-93C1F9C2CD16} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {7F222AD4-1F9E-4AAB-9D69-D62372D4C1BA} diff --git a/Tests/RGB.NET.Core.Tests/Color/ColorTest.cs b/Tests/RGB.NET.Core.Tests/Color/ColorTest.cs new file mode 100644 index 0000000..8146006 --- /dev/null +++ b/Tests/RGB.NET.Core.Tests/Color/ColorTest.cs @@ -0,0 +1,395 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace RGB.NET.Core.Tests.Color +{ + [TestClass] + public class ColorTest + { + #region Basics + + [TestMethod] + public void VerifyTransparent() + { + Core.Color transparent = Core.Color.Transparent; + + Assert.AreEqual(0, transparent.A, "A is not 0"); + Assert.AreEqual(0, transparent.R, "R is not 0"); + Assert.AreEqual(0, transparent.G, "G is not 0"); + Assert.AreEqual(0, transparent.B, "B is not 0"); + } + + [TestMethod] + public void ToStringTest() + { + Core.Color color = new Core.Color(255, 120, 13, 1); + + Assert.AreEqual("[A: 255, R: 120, G: 13, B: 1]", color.ToString()); + } + + #region HashCode + + [TestMethod] + public void GetHashCodeTestEqual() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(100, 68, 32, 255); + + Assert.AreEqual(color1.GetHashCode(), color2.GetHashCode()); + } + + [TestMethod] + public void GetHashCodeTestNotEqualA() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(99, 68, 32, 255); + + Assert.AreNotEqual(color1.GetHashCode(), color2.GetHashCode()); + } + + [TestMethod] + public void GetHashCodeTestNotEqualR() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(100, 69, 32, 255); + + Assert.AreNotEqual(color1.GetHashCode(), color2.GetHashCode()); + } + + [TestMethod] + public void GetHashCodeTestNotEqualG() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(100, 68, 200, 255); + + Assert.AreNotEqual(color1.GetHashCode(), color2.GetHashCode()); + } + + [TestMethod] + public void GetHashCodeTestNotEqualB() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(100, 68, 32, 0); + + Assert.AreNotEqual(color1.GetHashCode(), color2.GetHashCode()); + } + + #endregion + + #region Equality + + [TestMethod] + public void EqualityTestEqual() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(100, 68, 32, 255); + + Assert.IsTrue(color1.Equals(color2), $"Equals returns false on equal colors {color1} and {color2}"); + Assert.IsTrue(color1 == color2, $"Equal-operator returns false on equal colors {color1} and {color2}"); + Assert.IsFalse(color1 != color2, $"Not-Equal-operator returns true on equal colors {color1} and {color2}"); + } + + [TestMethod] + public void EqualityTestNotEqualA() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(99, 68, 32, 255); + + Assert.IsFalse(color1.Equals(color2), $"Equals returns true on not equal colors {color1} and {color2}"); + Assert.IsFalse(color1 == color2, $"Equal-operator returns true on not equal colors {color1} and {color2}"); + Assert.IsTrue(color1 != color2, $"Not-Equal-operator returns false on not equal colors {color1} and {color2}"); + } + + [TestMethod] + public void EqualityTestNotEqualR() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(100, 69, 32, 255); + + Assert.IsFalse(color1.Equals(color2), $"Equals returns true on not equal colors {color1} and {color2}"); + Assert.IsFalse(color1 == color2, $"Equal-operator returns true on not equal colors {color1} and {color2}"); + Assert.IsTrue(color1 != color2, $"Not-Equal-operator returns false on not equal colors {color1} and {color2}"); + } + + [TestMethod] + public void EqualityTestNotEqualG() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(100, 68, 200, 255); + + Assert.IsFalse(color1.Equals(color2), $"Equals returns true on not equal colors {color1} and {color2}"); + Assert.IsFalse(color1 == color2, $"Equal-operator returns true on not equal colors {color1} and {color2}"); + Assert.IsTrue(color1 != color2, $"Not-Equal-operator returns false on not equal colors {color1} and {color2}"); + } + + [TestMethod] + public void EqualityTestNotEqualB() + { + Core.Color color1 = new Core.Color(100, 68, 32, 255); + Core.Color color2 = new Core.Color(100, 68, 32, 0); + + Assert.IsFalse(color1.Equals(color2), $"Equals returns true on not equal colors {color1} and {color2}"); + Assert.IsFalse(color1 == color2, $"Equal-operator returns true on not equal colors {color1} and {color2}"); + Assert.IsTrue(color1 != color2, $"Not-Equal-operator returns false on not equal colors {color1} and {color2}"); + } + + #endregion + + #endregion + + #region Constructors + + [TestMethod] + public void RGBByteConstructorTest() + { + Core.Color color = new Core.Color((byte)10, (byte)120, (byte)255); + + Assert.AreEqual(255, color.A, "A is not 255"); + Assert.AreEqual(10, color.R, "R is not 10"); + Assert.AreEqual(120, color.G, "G is not 120"); + Assert.AreEqual(255, color.B, "B is not 255"); + } + + [TestMethod] + public void ARGBByteConstructorTest() + { + Core.Color color = new Core.Color((byte)200, (byte)10, (byte)120, (byte)255); + + Assert.AreEqual(200, color.A, "A is not 200"); + Assert.AreEqual(10, color.R, "R is not 10"); + Assert.AreEqual(120, color.G, "G is not 120"); + Assert.AreEqual(255, color.B, "B is not 255"); + } + + [TestMethod] + public void RGBIntConstructorTest() + { + Core.Color color = new Core.Color(10, 120, 255); + + Assert.AreEqual(255, color.A, "A is not 255"); + Assert.AreEqual(10, color.R, "R is not 10"); + Assert.AreEqual(120, color.G, "G is not 120"); + Assert.AreEqual(255, color.B, "B is not 255"); + } + + [TestMethod] + public void ARGBIntConstructorTest() + { + Core.Color color = new Core.Color(200, 10, 120, 255); + + Assert.AreEqual(200, color.A, "A is not 200"); + Assert.AreEqual(10, color.R, "R is not 10"); + Assert.AreEqual(120, color.G, "G is not 120"); + Assert.AreEqual(255, color.B, "B is not 255"); + } + + [TestMethod] + public void RGBIntConstructorClampTest() + { + Core.Color color1 = new Core.Color(256, 256, 256); + + Assert.AreEqual(255, color1.A, "A is not 255"); + Assert.AreEqual(255, color1.R, "R is not 255"); + Assert.AreEqual(255, color1.G, "G is not 255"); + Assert.AreEqual(255, color1.B, "B is not 255"); + + Core.Color color2 = new Core.Color(-1, -1, -1); + + Assert.AreEqual(255, color2.A, "A is not 255"); + Assert.AreEqual(0, color2.R, "R is not 0"); + Assert.AreEqual(0, color2.G, "G is not 0"); + Assert.AreEqual(0, color2.B, "B is not 0"); + } + + [TestMethod] + public void ARGBIntConstructorClampTest() + { + Core.Color color = new Core.Color(256, 256, 256, 256); + + Assert.AreEqual(255, color.A, "A is not 255"); + Assert.AreEqual(255, color.R, "R is not 255"); + Assert.AreEqual(255, color.G, "G is not 255"); + Assert.AreEqual(255, color.B, "B is not 255"); + + Core.Color color2 = new Core.Color(-1, -1, -1, -1); + + Assert.AreEqual(0, color2.A, "A is not 0"); + Assert.AreEqual(0, color2.R, "R is not 0"); + Assert.AreEqual(0, color2.G, "G is not 0"); + Assert.AreEqual(0, color2.B, "B is not 0"); + } + + [TestMethod] + public void RGBPercentConstructorTest() + { + Core.Color color = new Core.Color(0.25341, 0.55367, 1); + + Assert.AreEqual(1, color.APercent, DoubleExtensions.TOLERANCE, "A is not 1"); + Assert.AreEqual(0.25341, color.RPercent, DoubleExtensions.TOLERANCE, "R is not 0.25341"); + Assert.AreEqual(0.55367, color.GPercent, DoubleExtensions.TOLERANCE, "G is not 0.55367"); + Assert.AreEqual(1, color.BPercent, DoubleExtensions.TOLERANCE, "B is not 1"); + } + + [TestMethod] + public void ARGBPercentConstructorTest() + { + Core.Color color = new Core.Color(0.3315, 0.25341, 0.55367, 1); + + Assert.AreEqual(0.3315, color.APercent, DoubleExtensions.TOLERANCE, "A is not 0.3315"); + Assert.AreEqual(0.25341, color.RPercent, DoubleExtensions.TOLERANCE, "R is not 0.25341"); + Assert.AreEqual(0.55367, color.GPercent, DoubleExtensions.TOLERANCE, "G is not 0.55367"); + Assert.AreEqual(1, color.BPercent, DoubleExtensions.TOLERANCE, "B is not 1"); + } + + [TestMethod] + public void RGBPercentConstructorClampTest() + { + Core.Color color1 = new Core.Color(1.1, 1.1, 1.1); + + Assert.AreEqual(1, color1.APercent, "A is not 1"); + Assert.AreEqual(1, color1.RPercent, "R is not 1"); + Assert.AreEqual(1, color1.GPercent, "G is not 1"); + Assert.AreEqual(1, color1.BPercent, "B is not 1"); + + Core.Color color2 = new Core.Color(-1.0, -1.0, -1.0); + + Assert.AreEqual(1, color2.APercent, "A is not 1"); + Assert.AreEqual(0, color2.RPercent, "R is not 0"); + Assert.AreEqual(0, color2.GPercent, "G is not 0"); + Assert.AreEqual(0, color2.BPercent, "B is not 0"); + } + + [TestMethod] + public void ARGBPercentConstructorClampTest() + { + Core.Color color1 = new Core.Color(1.1, 1.1, 1.1, 1.1); + + Assert.AreEqual(1, color1.APercent, "A is not 1"); + Assert.AreEqual(1, color1.RPercent, "R is not 1"); + Assert.AreEqual(1, color1.GPercent, "G is not 1"); + Assert.AreEqual(1, color1.BPercent, "B is not 1"); + + Core.Color color2 = new Core.Color(-1.0, -1.0, -1.0, -1.0); + + Assert.AreEqual(0, color2.APercent, "A is not 0"); + Assert.AreEqual(0, color2.RPercent, "R is not 0"); + Assert.AreEqual(0, color2.GPercent, "G is not 0"); + Assert.AreEqual(0, color2.BPercent, "B is not 0"); + } + + [TestMethod] + public void CloneConstructorTest() + { + Core.Color referennceColor = new Core.Color(200, 10, 120, 255); + Core.Color color = new Core.Color(referennceColor); + + Assert.AreEqual(200, color.A, "A is not 200"); + Assert.AreEqual(10, color.R, "R is not 10"); + Assert.AreEqual(120, color.G, "G is not 120"); + Assert.AreEqual(255, color.B, "B is not 255"); + } + + #endregion + + #region Conversion + + [TestMethod] + public void ColorFromComponentsTest() + { + Core.Color color = (255, 120, 13, 1); + + Assert.AreEqual(255, color.A, $"A doesn't equal the used component. ({color.A} != 255)"); + Assert.AreEqual(120, color.R, $"R doesn't equal the used component. ({color.R} != 120)"); + Assert.AreEqual(13, color.G, $"G doesn't equal the used component. ({color.G} != 13)"); + Assert.AreEqual(1, color.B, $"B doesn't equal the used component. ({color.B} != 1)"); + } + + [TestMethod] + public void DesconstructTest() + { + (byte a, byte r, byte g, byte b) = new Core.Color(255, 120, 13, 1); + + Assert.AreEqual(255, a, $"A doesn't equal the color. ({a} != 255)"); + Assert.AreEqual(120, r, $"R doesn't equal the color. ({r} != 120)"); + Assert.AreEqual(13, g, $"G doesn't equal the color. ({g} != 13)"); + Assert.AreEqual(1, b, $"B doesn't equal the color. ({b} != 1)"); + } + + [TestMethod] + public void AToPercentTest() + { + Core.Color color1 = new Core.Color(0, 0, 0, 0); + Assert.AreEqual(0, color1.APercent); + + Core.Color color2 = new Core.Color(255, 0, 0, 0); + Assert.AreEqual(1, color2.APercent); + + Core.Color color3 = new Core.Color(128, 0, 0, 0); + Assert.AreEqual(128 / 255.0, color3.APercent); + + Core.Color color4 = new Core.Color(30, 0, 0, 0); + Assert.AreEqual(30 / 255.0, color4.APercent); + + Core.Color color5 = new Core.Color(201, 0, 0, 0); + Assert.AreEqual(201 / 255.0, color5.APercent); + } + + [TestMethod] + public void RToPercentTest() + { + Core.Color color1 = new Core.Color(0, 0, 0, 0); + Assert.AreEqual(0, color1.RPercent); + + Core.Color color2 = new Core.Color(0, 255, 0, 0); + Assert.AreEqual(1, color2.RPercent); + + Core.Color color3 = new Core.Color(0, 128, 0, 0); + Assert.AreEqual(128 / 255.0, color3.RPercent); + + Core.Color color4 = new Core.Color(0, 30, 0, 0); + Assert.AreEqual(30 / 255.0, color4.RPercent); + + Core.Color color5 = new Core.Color(0, 201, 0, 0); + Assert.AreEqual(201 / 255.0, color5.RPercent); + } + + [TestMethod] + public void GToPercentTest() + { + Core.Color color1 = new Core.Color(0, 0, 0, 0); + Assert.AreEqual(0, color1.GPercent); + + Core.Color color2 = new Core.Color(0, 0, 255, 0); + Assert.AreEqual(1, color2.GPercent); + + Core.Color color3 = new Core.Color(0, 0, 128, 0); + Assert.AreEqual(128 / 255.0, color3.GPercent); + + Core.Color color4 = new Core.Color(0, 0, 30, 0); + Assert.AreEqual(30 / 255.0, color4.GPercent); + + Core.Color color5 = new Core.Color(0, 0, 201, 0); + Assert.AreEqual(201 / 255.0, color5.GPercent); + } + + [TestMethod] + public void BToPercentTest() + { + Core.Color color1 = new Core.Color(0, 0, 0, 0); + Assert.AreEqual(0, color1.BPercent); + + Core.Color color2 = new Core.Color(0, 0, 0, 255); + Assert.AreEqual(1, color2.BPercent); + + Core.Color color3 = new Core.Color(0, 0, 0, 128); + Assert.AreEqual(128 / 255.0, color3.BPercent); + + Core.Color color4 = new Core.Color(0, 0, 0, 30); + Assert.AreEqual(30 / 255.0, color4.BPercent); + + Core.Color color5 = new Core.Color(0, 0, 0, 201); + Assert.AreEqual(201 / 255.0, color5.BPercent); + } + + #endregion + } +} diff --git a/Tests/RGB.NET.Core.Tests/Color/HSVColorTest.cs b/Tests/RGB.NET.Core.Tests/Color/HSVColorTest.cs new file mode 100644 index 0000000..6d5c9ba --- /dev/null +++ b/Tests/RGB.NET.Core.Tests/Color/HSVColorTest.cs @@ -0,0 +1,308 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace RGB.NET.Core.Tests.Color +{ + [TestClass] + public class HSVColorTest + { + #region Manipulation + + #region Blend + + [TestMethod] + public void BlendOpaqueTest() + { + Assert.Inconclusive(); + //Core.Color baseColor = new Core.Color(255, 0, 0); + //Core.Color blendColor = new Core.Color(0, 255, 0); + + //Assert.AreEqual(blendColor, baseColor.Blend(blendColor)); + } + + [TestMethod] + public void BlendTransparentTest() + { + Assert.Inconclusive(); + //Core.Color baseColor = new Core.Color(255, 0, 0); + //Core.Color blendColor = new Core.Color(0, 0, 255, 0); + + //Assert.AreEqual(baseColor, baseColor.Blend(blendColor)); + } + + #endregion + + #region Add + + [TestMethod] + public void AddHueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.AddHue(30); + + Assert.AreEqual(Core.Color.FromHSV(210, 0.5, 0.5), result); + } + + [TestMethod] + public void AddHueWrapTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.AddHue(220); + + Assert.AreEqual(Core.Color.FromHSV(40, 0.5, 0.5), result); + } + + [TestMethod] + public void AddSaturationTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.AddSaturation(0.3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.8, 0.5), result); + } + + [TestMethod] + public void AddSaturationClampTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.AddSaturation(0.8); + + Assert.AreEqual(Core.Color.FromHSV(180, 1.0, 0.5), result); + } + + [TestMethod] + public void AddValueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.AddValue(0.3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.5, 0.8), result); + } + + [TestMethod] + public void AddValueClampTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.AddValue(0.8); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.5, 1.0), result); + } + + #endregion + + #region Subtract + + [TestMethod] + public void SubtractHueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SubtractHue(30); + + Assert.AreEqual(Core.Color.FromHSV(150, 0.5, 0.5), result); + } + + [TestMethod] + public void SubtractHueWrapTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SubtractHue(220); + + Assert.AreEqual(Core.Color.FromHSV(320, 0.5, 0.5), result); + } + + [TestMethod] + public void SubtractSaturationTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SubtractSaturation(0.3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.2, 0.5), result); + } + + [TestMethod] + public void SubtractSaturationClampTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SubtractSaturation(0.8); + + Assert.AreEqual(Core.Color.FromHSV(180, 0, 0.5), result); + } + + [TestMethod] + public void SubtractValueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SubtractValue(0.3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.5, 0.2), result); + } + + [TestMethod] + public void SubtractValueClampTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SubtractValue(0.8); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.5, 0), result); + } + + #endregion + + #region Multiply + + [TestMethod] + public void MultiplyHueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.MultiplyHue(1.5); + + Assert.AreEqual(Core.Color.FromHSV(270, 0.5, 0.5), result); + } + + [TestMethod] + public void MultiplyHueWrapTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.MultiplyHue(3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.5, 0.5), result); + } + + [TestMethod] + public void MultiplySaturationTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.2, 0.2); + Core.Color result = baseColor.MultiplySaturation(3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.6, 0.2), result); + } + + [TestMethod] + public void MultiplySaturationClampTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.MultiplySaturation(3); + + Assert.AreEqual(Core.Color.FromHSV(180, 1.0, 0.5), result); + } + + [TestMethod] + public void MultiplyValueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.2, 0.2); + Core.Color result = baseColor.MultiplyValue(3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.2, 0.6), result); + } + + [TestMethod] + public void MultiplyValueClampTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.MultiplyValue(3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.5, 1.0), result); + } + + #endregion + + #region Divide + + [TestMethod] + public void DivideHueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.DivideHue(30); + + Assert.AreEqual(Core.Color.FromHSV(6, 0.5, 0.5), result); + } + + [TestMethod] + public void DivideSaturationTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.6, 0.6); + Core.Color result = baseColor.DivideSaturation(2); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.3, 0.6), result); + } + + [TestMethod] + public void DivideValueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.6, 0.6); + Core.Color result = baseColor.DivideValue(2); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.6, 0.3), result); + } + + #endregion + + #region Set + + [TestMethod] + public void SetHueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SetHue(30); + + Assert.AreEqual(Core.Color.FromHSV(30, 0.5, 0.5), result); + } + + [TestMethod] + public void SetHueWrapTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SetHue(440); + + Assert.AreEqual(Core.Color.FromHSV(80, 0.5, 0.5), result); + } + + [TestMethod] + public void SetHueWrapNegativeTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SetHue(-30); + + Assert.AreEqual(Core.Color.FromHSV(330, 0.5, 0.5), result); + } + + [TestMethod] + public void SetSaturationTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SetSaturation(0.3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.3, 0.5), result); + } + + [TestMethod] + public void SetSaturationClampTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SetSaturation(2); + + Assert.AreEqual(Core.Color.FromHSV(180, 1.0, 0.5), result); + } + + [TestMethod] + public void SetValueTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SetValue(0.3); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.5, 0.3), result); + } + + [TestMethod] + public void SetValueClampTest() + { + Core.Color baseColor = Core.Color.FromHSV(180, 0.5, 0.5); + Core.Color result = baseColor.SetValue(2); + + Assert.AreEqual(Core.Color.FromHSV(180, 0.5, 1.0), result); + } + + #endregion + + #endregion + } +} diff --git a/Tests/RGB.NET.Core.Tests/Color/RGBColorTest.cs b/Tests/RGB.NET.Core.Tests/Color/RGBColorTest.cs new file mode 100644 index 0000000..f2753e7 --- /dev/null +++ b/Tests/RGB.NET.Core.Tests/Color/RGBColorTest.cs @@ -0,0 +1,504 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace RGB.NET.Core.Tests.Color +{ + [TestClass] + public class RGBColorTest + { + #region Manipulation + + #region Blend + + [TestMethod] + public void BlendOpaqueTest() + { + Core.Color baseColor = new Core.Color(255, 0, 0); + Core.Color blendColor = new Core.Color(0, 255, 0); + + Assert.AreEqual(blendColor, baseColor.Blend(blendColor)); + } + + [TestMethod] + public void BlendTransparentTest() + { + Core.Color baseColor = new Core.Color(255, 0, 0); + Core.Color blendColor = new Core.Color(0, 0, 255, 0); + + Assert.AreEqual(baseColor, baseColor.Blend(blendColor)); + } + + [TestMethod] + public void BlendUpTest() + { + Core.Color baseColor = new Core.Color(0.0, 0.0, 0.0); + Core.Color blendColor = new Core.Color(0.5, 1.0, 1.0, 1.0); + + Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5), baseColor.Blend(blendColor)); + } + + [TestMethod] + public void BlendDownTest() + { + Core.Color baseColor = new Core.Color(1.0, 1.0, 1.0); + Core.Color blendColor = new Core.Color(1.0, 0.0, 0.0, 0.0); + + Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5), baseColor.Blend(blendColor)); + } + + #endregion + + #region Add + + [TestMethod] + public void AddRGBTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.AddRGB(11, 12, 13); + + Assert.AreEqual(new Core.Color(128, 139, 140, 141), result); + } + + [TestMethod] + public void AddARGBTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.AddRGB(10, 11, 12, 13); + + Assert.AreEqual(new Core.Color(138, 139, 140, 141), result); + } + + [TestMethod] + public void AddRGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.AddPercent(0.2, 0.3, 0.4); + + Assert.AreEqual(new Core.Color(0.5, 0.7, 0.8, 0.9), result); + } + + [TestMethod] + public void AddARGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.AddPercent(0.1, 0.2, 0.3, 0.4); + + Assert.AreEqual(new Core.Color(0.6, 0.7, 0.8, 0.9), result); + } + + [TestMethod] + public void AddATest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.AddA(10); + + Assert.AreEqual(new Core.Color(138, 128, 128, 128), result); + } + + [TestMethod] + public void AddAPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.AddAPercent(0.1); + + Assert.AreEqual(new Core.Color(0.6, 0.5, 0.5, 0.5), result); + } + + [TestMethod] + public void AddRTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.AddR(10); + + Assert.AreEqual(new Core.Color(128, 138, 128, 128), result); + } + + [TestMethod] + public void AddRPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.AddRPercent(0.1); + + Assert.AreEqual(new Core.Color(0.5, 0.6, 0.5, 0.5), result); + } + + [TestMethod] + public void AddGTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.AddG(10); + + Assert.AreEqual(new Core.Color(128, 128, 138, 128), result); + } + + [TestMethod] + public void AddGPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.AddGPercent(0.1); + + Assert.AreEqual(new Core.Color(0.5, 0.5, 0.6, 0.5), result); + } + + [TestMethod] + public void AddBTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.AddB(10); + + Assert.AreEqual(new Core.Color(128, 128, 128, 138), result); + } + + [TestMethod] + public void AddBPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.AddBPercent(0.1); + + Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5, 0.6), result); + } + + #endregion + + #region Substract + + [TestMethod] + public void SubtractRGBTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SubtractRGB(11, 12, 13); + + Assert.AreEqual(new Core.Color(128, 117, 116, 115), result); + } + + [TestMethod] + public void SubtractARGBTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SubtractRGB(10, 11, 12, 13); + + Assert.AreEqual(new Core.Color(118, 117, 116, 115), result); + } + + [TestMethod] + public void SubtractRGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SubtractPercent(0.2, 0.3, 0.4); + + Assert.AreEqual(new Core.Color(0.5, 0.3, 0.2, 0.1), result); + } + + [TestMethod] + public void SubtractARGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SubtractPercent(0.1, 0.2, 0.3, 0.4); + + Assert.AreEqual(new Core.Color(0.4, 0.3, 0.2, 0.1), result); + } + + [TestMethod] + public void SubtractATest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SubtractA(10); + + Assert.AreEqual(new Core.Color(118, 128, 128, 128), result); + } + + [TestMethod] + public void SubtractAPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SubtractAPercent(0.1); + + Assert.AreEqual(new Core.Color(0.4, 0.5, 0.5, 0.5), result); + } + + [TestMethod] + public void SubtractRTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SubtractR(10); + + Assert.AreEqual(new Core.Color(128, 118, 128, 128), result); + } + + [TestMethod] + public void SubtractRPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SubtractRPercent(0.1); + + Assert.AreEqual(new Core.Color(0.5, 0.4, 0.5, 0.5), result); + } + + [TestMethod] + public void SubtractGTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SubtractG(10); + + Assert.AreEqual(new Core.Color(128, 128, 118, 128), result); + } + + [TestMethod] + public void SubtractGPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SubtractGPercent(0.1); + + Assert.AreEqual(new Core.Color(0.5, 0.5, 0.4, 0.5), result); + } + + [TestMethod] + public void SubtractBTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SubtractB(10); + + Assert.AreEqual(new Core.Color(128, 128, 128, 118), result); + } + + [TestMethod] + public void SubtractBPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SubtractBPercent(0.1); + + Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5, 0.4), result); + } + + #endregion + + #region Multiply + + [TestMethod] + public void MultiplyRGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2); + Core.Color result = baseColor.MultiplyPercent(3, 4, 5); + + Assert.AreEqual(new Core.Color(0.2, 0.6, 0.8, 1.0), result); + } + + [TestMethod] + public void MultiplyARGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2); + Core.Color result = baseColor.MultiplyPercent(2, 3, 4, 5); + + Assert.AreEqual(new Core.Color(0.4, 0.6, 0.8, 1.0), result); + } + + [TestMethod] + public void MultiplyAPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2); + Core.Color result = baseColor.MultiplyAPercent(3); + + Assert.AreEqual(new Core.Color(0.6, 0.2, 0.2, 0.2), result); + } + + [TestMethod] + public void MultiplyRPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2); + Core.Color result = baseColor.MultiplyRPercent(3); + + Assert.AreEqual(new Core.Color(0.2, 0.6, 0.2, 0.2), result); + } + + [TestMethod] + public void MultiplyGPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2); + Core.Color result = baseColor.MultiplyGPercent(3); + + Assert.AreEqual(new Core.Color(0.2, 0.2, 0.6, 0.2), result); + } + + [TestMethod] + public void MultiplyBPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2); + Core.Color result = baseColor.MultiplyBPercent(3); + + Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.6), result); + } + + #endregion + + #region Divide + + [TestMethod] + public void DivideRGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.6, 0.8, 1.0); + Core.Color result = baseColor.DividePercent(3, 4, 5); + + Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result); + } + + [TestMethod] + public void DivideARGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.4, 0.6, 0.8, 1.0); + Core.Color result = baseColor.DividePercent(2, 3, 4, 5); + + Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result); + } + + [TestMethod] + public void DivideAPercentTest() + { + Core.Color baseColor = new Core.Color(0.6, 0.2, 0.2, 0.2); + Core.Color result = baseColor.DivideAPercent(3); + + Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result); + } + + [TestMethod] + public void DivideRPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.6, 0.2, 0.2); + Core.Color result = baseColor.DivideRPercent(3); + + Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result); + } + + [TestMethod] + public void DivideGPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.2, 0.6, 0.2); + Core.Color result = baseColor.DivideGPercent(3); + + Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result); + } + + [TestMethod] + public void DivideBPercentTest() + { + Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.6); + Core.Color result = baseColor.DivideBPercent(3); + + Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result); + } + + #endregion + + #region Set + + [TestMethod] + public void SetRGBTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SetR(11).SetG(12).SetB(13); + + Assert.AreEqual(new Core.Color(128, 11, 12, 13), result); + } + + [TestMethod] + public void SetARGBTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SetA(10).SetR(11).SetG(12).SetB(13); + + Assert.AreEqual(new Core.Color(10, 11, 12, 13), result); + } + + [TestMethod] + public void SetRGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SetRPercent(0.2).SetGPercent(0.3).SetBPercent(0.4); + + Assert.AreEqual(new Core.Color(0.5, 0.2, 0.3, 0.4), result); + } + + [TestMethod] + public void SetARGBPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SetAPercent(0.1).SetRPercent(0.2).SetGPercent(0.3).SetBPercent(0.4); + + Assert.AreEqual(new Core.Color(0.1, 0.2, 0.3, 0.4), result); + } + + [TestMethod] + public void SetATest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SetA(10); + + Assert.AreEqual(new Core.Color(10, 128, 128, 128), result); + } + + [TestMethod] + public void SetAPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SetAPercent(0.1); + + Assert.AreEqual(new Core.Color(0.1, 0.5, 0.5, 0.5), result); + } + + [TestMethod] + public void SetRTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SetR(10); + + Assert.AreEqual(new Core.Color(128, 10, 128, 128), result); + } + + [TestMethod] + public void SetRPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SetRPercent(0.1); + + Assert.AreEqual(new Core.Color(0.5, 0.1, 0.5, 0.5), result); + } + + [TestMethod] + public void SetGTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SetG(10); + + Assert.AreEqual(new Core.Color(128, 128, 10, 128), result); + } + + [TestMethod] + public void SetGPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SetGPercent(0.1); + + Assert.AreEqual(new Core.Color(0.5, 0.5, 0.1, 0.5), result); + } + + [TestMethod] + public void SetBTest() + { + Core.Color baseColor = new Core.Color(128, 128, 128, 128); + Core.Color result = baseColor.SetB(10); + + Assert.AreEqual(new Core.Color(128, 128, 128, 10), result); + } + + [TestMethod] + public void SetBPercentTest() + { + Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5); + Core.Color result = baseColor.SetBPercent(0.1); + + Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5, 0.1), result); + } + + #endregion + + #endregion + } +} diff --git a/Tests/RGB.NET.Core.Tests/RGB.NET.Core.Tests.csproj b/Tests/RGB.NET.Core.Tests/RGB.NET.Core.Tests.csproj new file mode 100644 index 0000000..49bf8e9 --- /dev/null +++ b/Tests/RGB.NET.Core.Tests/RGB.NET.Core.Tests.csproj @@ -0,0 +1,19 @@ + + + + netcoreapp2.2 + + false + + + + + + + + + + + + +