Add some Cmyk tests

tests/ImageSharp.Tests/Colorspaces/Conversion/CmykAndCieLchConversionTests.cs

@@ -0,0 +1,78 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="Cmyk"/>-<see cref="CieLch"/> conversions.
+    /// </summary>
+    public class CmykAndCieLchConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="Cmyk"/> to <see cref="CieLch"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0.360555, 0.1036901, 0.818514, 0.274615, 62.85025, 64.77041, 118.2425)]
+        public void Convert_Cmyk_to_CieLch(float c, float m, float y, float k, float l, float c2, float h)
+        {
+            // Arrange
+            var input = new Cmyk(c, m, y, k);
+            var expected = new CieLch(l, c2, h);
+
+            Span<Cmyk> inputSpan = new Cmyk[5];
+            inputSpan.Fill(input);
+
+            Span<CieLch> actualSpan = new CieLch[5];
+
+            // Act
+            var actual = Converter.ToCieLch(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLch"/> to <see cref="Cmyk"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(100, 3.81656E-05, 218.6598, 0, 1.192093E-07, 0, 5.960464E-08)]
+        [InlineData(62.85025, 64.77041, 118.2425, 0.286581, 0, 0.7975187, 0.34983)]
+        public void Convert_CieLch_to_Cmyk(float l, float c2, float h, float c, float m, float y, float k)
+        {
+            // Arrange
+            var input = new CieLch(l, c2, h);
+            var expected = new Cmyk(c, m, y, k);
+
+            Span<CieLch> inputSpan = new CieLch[5];
+            inputSpan.Fill(input);
+
+            Span<Cmyk> actualSpan = new Cmyk[5];
+
+            // Act
+            var actual = Converter.ToCmyk(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CmykAndCieLuvConversionTests.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="Cmyk"/>-<see cref="CieLuv"/> conversions.
+    /// </summary>
+    public class CmykAndCieLuvConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="Cmyk"/> to <see cref="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 100, -1.937151E-05, 0)]
+        [InlineData(0.360555, 0.1036901, 0.818514, 0.274615, 62.66017, -24.01712, 68.29556)]
+        public void Convert_Cmyk_to_CieLuv(float c, float m, float y, float k, float l, float u, float v)
+        {
+            // Arrange
+            var input = new Cmyk(c, m, y, k);
+            var expected = new CieLuv(l, u, v);
+
+            Span<Cmyk> inputSpan = new Cmyk[5];
+            inputSpan.Fill(input);
+
+            Span<CieLuv> actualSpan = new CieLuv[5];
+
+            // Act
+            var actual = Converter.ToCieLuv(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="Cmyk"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(100, -1.937151E-05, 0, 3.576279E-07, 0, 0, 5.960464E-08)]
+        [InlineData(62.66017, -24.01712, 68.29556, 0.2865804, 0, 0.7975189, 0.3498302)]
+        public void Convert_CieLuv_to_Cmyk(float l, float u, float v, float c, float m, float y, float k)
+        {
+            // Arrange
+            var input = new CieLuv(l, u, v);
+            var expected = new Cmyk(c, m, y, k);
+
+            Span<CieLuv> inputSpan = new CieLuv[5];
+            inputSpan.Fill(input);
+
+            Span<Cmyk> actualSpan = new Cmyk[5];
+
+            // Act
+            var actual = Converter.ToCmyk(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CmykAndCieXyyConversionTests.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="Cmyk"/>-<see cref="CieXyy"/> conversions.
+    /// </summary>
+    public class CmykAndCieXyyConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="Cmyk"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0.3127266, 0.3290231, 1)]
+        [InlineData(0.360555, 0.1036901, 0.818514, 0.274615, 0.3628971, 0.5289949, 0.3118104)]
+        public void Convert_Cmyk_to_CieXyy(float c, float m, float y, float k, float x, float y2, float yl)
+        {
+            // Arrange
+            var input = new Cmyk(c, m, y, k);
+            var expected = new CieXyy(x, y2, yl);
+
+            Span<Cmyk> inputSpan = new Cmyk[5];
+            inputSpan.Fill(input);
+
+            Span<CieXyy> actualSpan = new CieXyy[5];
+
+            // Act
+            var actual = Converter.ToCieXyy(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="Cmyk"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0.3127266, 0.3290231, 1, 0, 0, 0, 5.960464E-08)]
+        [InlineData(0.3628971, 0.5289949, 0.3118104, 0.2865805, 0, 0.7975187, 0.3498302)]
+        public void Convert_CieXyy_to_Cmyk(float x, float y2, float yl, float c, float m, float y, float k)
+        {
+            // Arrange
+            var input = new CieXyy(x, y2, yl);
+            var expected = new Cmyk(c, m, y, k);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<Cmyk> actualSpan = new Cmyk[5];
+
+            // Act
+            var actual = Converter.ToCmyk(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CmykAndCieXyzConversionTests.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="Cmyk"/>-<see cref="CieXyz"/> conversions.
+    /// </summary>
+    public class CmykAndCieXyzConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="Cmyk"/> to <see cref="CieXyz"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0.9504699, 1, 1.08883)]
+        [InlineData(0.360555, 0.1036901, 0.818514, 0.274615, 0.2139058, 0.3118104, 0.0637231)]
+        public void Convert_Cmyk_to_CieXyz(float c, float m, float y, float k, float x, float y2, float z)
+        {
+            // Arrange
+            var input = new Cmyk(c, m, y, k);
+            var expected = new CieXyz(x, y2, z);
+
+            Span<Cmyk> inputSpan = new Cmyk[5];
+            inputSpan.Fill(input);
+
+            Span<CieXyz> actualSpan = new CieXyz[5];
+
+            // Act
+            var actual = Converter.ToCieXyz(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyz"/> to <see cref="Cmyk"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0.9504699, 1, 1.08883, 1.192093E-07, 0, 0, 5.960464E-08)]
+        [InlineData(0.2139058, 0.3118104, 0.0637231, 0.2865805, 0, 0.7975187, 0.3498302)]
+        public void Convert_CieXyz_to_Cmyk(float x, float y2, float z, float c, float m, float y, float k)
+        {
+            // Arrange
+            var input = new CieXyz(x, y2, z);
+            var expected = new Cmyk(c, m, y, k);
+
+            Span<CieXyz> inputSpan = new CieXyz[5];
+            inputSpan.Fill(input);
+
+            Span<Cmyk> actualSpan = new Cmyk[5];
+
+            // Act
+            var actual = Converter.ToCmyk(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CmykAndHslConversionTests.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="Cmyk"/>-<see cref="Hsl"/> conversions.
+    /// </summary>
+    public class CmykAndHslConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="Cmyk"/> to <see cref="Hsl"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0, 1)]
+        [InlineData(0.360555, 0.1036901, 0.818514, 0.274615, 81.56041, 0.6632275, 0.3909085)]
+        public void Convert_Cmyk_to_Hsl(float c, float m, float y, float k, float h, float s, float l)
+        {
+            // Arrange
+            var input = new Cmyk(c, m, y, k);
+            var expected = new Hsl(h, s, l);
+
+            Span<Cmyk> inputSpan = new Cmyk[5];
+            inputSpan.Fill(input);
+
+            Span<Hsl> actualSpan = new Hsl[5];
+
+            // Act
+            var actual = Converter.ToHsl(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="Hsl"/> to <see cref="Cmyk"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 1, 0, 0, 0, 0)]
+        [InlineData(81.56041, 0.6632275, 0.3909085, 0.2865805, 0, 0.7975187, 0.3498302)]
+        public void Convert_Hsl_to_Cmyk(float h, float s, float l, float c, float m, float y, float k)
+        {
+            // Arrange
+            var input = new Hsl(h, s, l);
+            var expected = new Cmyk(c, m, y, k);
+
+            Span<Hsl> inputSpan = new Hsl[5];
+            inputSpan.Fill(input);
+
+            Span<Cmyk> actualSpan = new Cmyk[5];
+
+            // Act
+            var actual = Converter.ToCmyk(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CmykAndHsvConversionTests.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="Cmyk"/>-<see cref="Hsv"/> conversions.
+    /// </summary>
+    public class CmykAndHsvConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="Cmyk"/> to <see cref="Hsv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0, 1)]
+        [InlineData(0.360555, 0.1036901, 0.818514, 0.274615, 81.56041, 0.7975187, 0.6501698)]
+        public void Convert_Cmyk_to_Hsv(float c, float m, float y, float k, float h, float s, float v)
+        {
+            // Arrange
+            var input = new Cmyk(c, m, y, k);
+            var expected = new Hsv(h, s, v);
+
+            Span<Cmyk> inputSpan = new Cmyk[5];
+            inputSpan.Fill(input);
+
+            Span<Hsv> actualSpan = new Hsv[5];
+
+            // Act
+            var actual = Converter.ToHsv(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="Hsv"/> to <see cref="Cmyk"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 1, 0, 0, 0, 0)]
+        [InlineData(81.56041, 0.7975187, 0.6501698, 0.2865805, 0, 0.7975187, 0.3498302)]
+        public void Convert_Hsv_to_Cmyk(float h, float s, float v, float c, float m, float y, float k)
+        {
+            // Arrange
+            var input = new Hsv(h, s, v);
+            var expected = new Cmyk(c, m, y, k);
+
+            Span<Hsv> inputSpan = new Hsv[5];
+            inputSpan.Fill(input);
+
+            Span<Cmyk> actualSpan = new Cmyk[5];
+
+            // Act
+            var actual = Converter.ToCmyk(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CmykAndHunterLabConversionTests.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="Cmyk"/>-<see cref="HunterLab"/> conversions.
+    /// </summary>
+    public class CmykAndHunterLabConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="Cmyk"/> to <see cref="HunterLab"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 99.99999, 0, -1.66893E-05)]
+        [InlineData(0.360555, 0.1036901, 0.818514, 0.274615, 55.66742, -27.21679, 31.73834)]
+        public void Convert_Cmyk_to_HunterLab(float c, float m, float y, float k, float l, float a, float b)
+        {
+            // Arrange
+            var input = new Cmyk(c, m, y, k);
+            var expected = new HunterLab(l, a, b);
+
+            Span<Cmyk> inputSpan = new Cmyk[5];
+            inputSpan.Fill(input);
+
+            Span<HunterLab> actualSpan = new HunterLab[5];
+
+            // Act
+            var actual = Converter.ToHunterLab(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="HunterLab"/> to <see cref="Cmyk"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(99.99999, 0, -1.66893E-05, 1.192093E-07, 1.192093E-07, 0, 5.960464E-08)]
+        [InlineData(55.66742, -27.21679, 31.73834, 0.2865806, 0, 0.7975186, 0.3498301)]
+        public void Convert_HunterLab_to_Cmyk(float l, float a, float b, float c, float m, float y, float k)
+        {
+            // Arrange
+            var input = new HunterLab(l, a, b);
+            var expected = new Cmyk(c, m, y, k);
+
+            Span<HunterLab> inputSpan = new HunterLab[5];
+            inputSpan.Fill(input);
+
+            Span<Cmyk> actualSpan = new Cmyk[5];
+
+            // Act
+            var actual = Converter.ToCmyk(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CmykAndYCbCrConversionTests.cs

@@ -9,7 +9,7 @@ using Xunit;
 namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
 {
     /// <summary>
-    /// Tests <see cref="YCbCr"/>-<see cref="Cmyk"/> conversions.
+    /// Tests <see cref="Cmyk"/>-<see cref="YCbCr"/> conversions.
     /// </summary>
     public class CmykAndYCbCrConversionTests
     {