Added tests for colors

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}

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
+    }
+}

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
+    }
+}

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
+    }
+}

Tests/RGB.NET.Core.Tests/RGB.NET.Core.Tests.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="1.3.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="1.3.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\RGB.NET.Core\RGB.NET.Core.csproj" />
+  </ItemGroup>
+
+</Project>