Add comparing intrinsics color conversion to scalar version

tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs

@@ -36,7 +36,7 @@ public class JpegColorConverterTests
     [Fact]
     public void GetConverterThrowsExceptionOnInvalidColorSpace()
     {
-        var invalidColorSpace = (JpegColorSpace)(-1);
+        JpegColorSpace invalidColorSpace = (JpegColorSpace)(-1);
         Assert.Throws<InvalidImageContentException>(() => JpegColorConverterBase.GetConverter(invalidColorSpace, 8));
     }
 
@@ -61,7 +61,7 @@ public class JpegColorConverterTests
     [InlineData(JpegColorSpace.YCbCr, 12)]
     internal void GetConverterReturnsValidConverter(JpegColorSpace colorSpace, int precision)
     {
-        var converter = JpegColorConverterBase.GetConverter(colorSpace, precision);
+        JpegColorConverterBase converter = JpegColorConverterBase.GetConverter(colorSpace, precision);
 
         Assert.NotNull(converter);
         Assert.True(converter.IsAvailable);
@@ -77,7 +77,7 @@ public class JpegColorConverterTests
     [InlineData(JpegColorSpace.YCbCr, 3)]
     internal void ConvertWithSelectedConverter(JpegColorSpace colorSpace, int componentCount)
     {
-        var converter = JpegColorConverterBase.GetConverter(colorSpace, 8);
+        JpegColorConverterBase converter = JpegColorConverterBase.GetConverter(colorSpace, 8);
         ValidateConversion(
             converter,
             componentCount,
@@ -93,7 +93,7 @@ public class JpegColorConverterTests
     [MemberData(nameof(Seeds))]
     public void FromYCbCrVector(int seed)
     {
-        var converter = new JpegColorConverterBase.YCbCrVector(8);
+        JpegColorConverterBase.YCbCrVector converter = new(8);
 
         if (!converter.IsAvailable)
         {
@@ -111,7 +111,8 @@ public class JpegColorConverterTests
             ValidateConversion(
                 new JpegColorConverterBase.YCbCrVector(8),
                 3,
-                FeatureTestRunner.Deserialize<int>(arg));
+                FeatureTestRunner.Deserialize<int>(arg),
+                new JpegColorConverterBase.YCbCrScalar(8));
     }
 
     [Theory]
@@ -123,7 +124,7 @@ public class JpegColorConverterTests
     [MemberData(nameof(Seeds))]
     public void FromCmykVector(int seed)
     {
-        var converter = new JpegColorConverterBase.CmykVector(8);
+        JpegColorConverterBase.CmykVector converter = new(8);
 
         if (!converter.IsAvailable)
         {
@@ -141,7 +142,8 @@ public class JpegColorConverterTests
             ValidateConversion(
                 new JpegColorConverterBase.CmykVector(8),
                 4,
-                FeatureTestRunner.Deserialize<int>(arg));
+                FeatureTestRunner.Deserialize<int>(arg),
+                new JpegColorConverterBase.CmykScalar(8));
     }
 
     [Theory]
@@ -153,7 +155,7 @@ public class JpegColorConverterTests
     [MemberData(nameof(Seeds))]
     public void FromGrayscaleVector(int seed)
     {
-        var converter = new JpegColorConverterBase.GrayScaleVector(8);
+        JpegColorConverterBase.GrayScaleVector converter = new JpegColorConverterBase.GrayScaleVector(8);
 
         if (!converter.IsAvailable)
         {
@@ -171,7 +173,8 @@ public class JpegColorConverterTests
             ValidateConversion(
                 new JpegColorConverterBase.GrayScaleVector(8),
                 1,
-                FeatureTestRunner.Deserialize<int>(arg));
+                FeatureTestRunner.Deserialize<int>(arg),
+                new JpegColorConverterBase.GrayscaleScalar(8));
     }
 
     [Theory]
@@ -183,7 +186,7 @@ public class JpegColorConverterTests
     [MemberData(nameof(Seeds))]
     public void FromRgbVector(int seed)
     {
-        var converter = new JpegColorConverterBase.RgbVector(8);
+        JpegColorConverterBase.RgbVector converter = new JpegColorConverterBase.RgbVector(8);
 
         if (!converter.IsAvailable)
         {
@@ -201,7 +204,8 @@ public class JpegColorConverterTests
             ValidateConversion(
                 new JpegColorConverterBase.RgbVector(8),
                 3,
-                FeatureTestRunner.Deserialize<int>(arg));
+                FeatureTestRunner.Deserialize<int>(arg),
+                new JpegColorConverterBase.RgbScalar(8));
     }
 
     [Theory]
@@ -213,7 +217,7 @@ public class JpegColorConverterTests
     [MemberData(nameof(Seeds))]
     public void FromYccKVector(int seed)
     {
-        var converter = new JpegColorConverterBase.YccKVector(8);
+        JpegColorConverterBase.YccKVector converter = new JpegColorConverterBase.YccKVector(8);
 
         if (!converter.IsAvailable)
         {
@@ -231,48 +235,50 @@ public class JpegColorConverterTests
             ValidateConversion(
                 new JpegColorConverterBase.YccKVector(8),
                 4,
-                FeatureTestRunner.Deserialize<int>(arg));
+                FeatureTestRunner.Deserialize<int>(arg),
+                new JpegColorConverterBase.YccKScalar(8));
     }
 
     [Theory]
     [MemberData(nameof(Seeds))]
     public void FromYCbCrAvx2(int seed) =>
-        this.TestConverter(new JpegColorConverterBase.YCbCrAvx(8), 3, seed);
+        this.TestConverter(new JpegColorConverterBase.YCbCrAvx(8), 3, seed, new JpegColorConverterBase.YCbCrScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
     public void FromCmykAvx2(int seed) =>
-        this.TestConverter(new JpegColorConverterBase.CmykAvx(8), 4, seed);
+        this.TestConverter(new JpegColorConverterBase.CmykAvx(8), 4, seed, new JpegColorConverterBase.CmykScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
     public void FromCmykArm(int seed) =>
-        this.TestConverter(new JpegColorConverterBase.CmykArm64(8), 4, seed);
+        this.TestConverter( new JpegColorConverterBase.CmykArm64(8), 4, seed, new JpegColorConverterBase.CmykScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
     public void FromGrayscaleAvx2(int seed) =>
-        this.TestConverter(new JpegColorConverterBase.GrayscaleAvx(8), 1, seed);
+        this.TestConverter(new JpegColorConverterBase.GrayscaleAvx(8), 1, seed, new JpegColorConverterBase.GrayscaleScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
     public void FromRgbAvx2(int seed) =>
-        this.TestConverter(new JpegColorConverterBase.RgbAvx(8), 3, seed);
+        this.TestConverter(new JpegColorConverterBase.RgbAvx(8), 3, seed, new JpegColorConverterBase.RgbScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
     public void FromRgbArm(int seed) =>
-        this.TestConverter(new JpegColorConverterBase.RgbArm(8), 3, seed);
+        this.TestConverter(new JpegColorConverterBase.RgbArm(8), 3, seed, new JpegColorConverterBase.RgbScalar(8));
 
     [Theory]
     [MemberData(nameof(Seeds))]
     public void FromYccKAvx2(int seed) =>
-        this.TestConverter(new JpegColorConverterBase.YccKAvx(8), 4, seed);
+        this.TestConverter( new JpegColorConverterBase.YccKAvx(8), 4, seed, new JpegColorConverterBase.YccKScalar(8));
 
     private void TestConverter(
         JpegColorConverterBase converter,
         int componentCount,
-        int seed)
+        int seed,
+        JpegColorConverterBase baseLineConverter = null)
     {
         if (!converter.IsAvailable)
         {
@@ -284,7 +290,8 @@ public class JpegColorConverterTests
         ValidateConversion(
             converter,
             componentCount,
-            seed);
+            seed,
+            baseLineConverter);
     }
 
     private static JpegColorConverterBase.ComponentValues CreateRandomValues(
@@ -316,21 +323,52 @@ public class JpegColorConverterTests
     private static void ValidateConversion(
         JpegColorConverterBase converter,
         int componentCount,
-        int seed)
+        int seed,
+        JpegColorConverterBase baseLineConverter = null)
     {
         JpegColorConverterBase.ComponentValues original = CreateRandomValues(TestBufferLength, componentCount, seed);
-        JpegColorConverterBase.ComponentValues values = new(
+        JpegColorConverterBase.ComponentValues actual = new(
                 original.ComponentCount,
                 original.Component0.ToArray(),
                 original.Component1.ToArray(),
                 original.Component2.ToArray(),
                 original.Component3.ToArray());
 
-        converter.ConvertToRgbInplace(values);
+        converter.ConvertToRgbInplace(actual);
 
         for (int i = 0; i < TestBufferLength; i++)
         {
-            Validate(converter.ColorSpace, original, values, i);
+            Validate(converter.ColorSpace, original, actual, i);
+        }
+
+        if (baseLineConverter != null)
+        {
+            JpegColorConverterBase.ComponentValues expected = new(
+                original.ComponentCount,
+                original.Component0.ToArray(),
+                original.Component1.ToArray(),
+                original.Component2.ToArray(),
+                original.Component3.ToArray());
+            baseLineConverter.ConvertToRgbInplace(expected);
+            if (componentCount == 1)
+            {
+                Assert.True(expected.Component0.SequenceEqual(actual.Component0));
+            }
+
+            if (componentCount == 2)
+            {
+                Assert.True(expected.Component1.SequenceEqual(actual.Component1));
+            }
+
+            if (componentCount == 3)
+            {
+                Assert.True(expected.Component2.SequenceEqual(actual.Component2));
+            }
+
+            if (componentCount == 4)
+            {
+                Assert.True(expected.Component3.SequenceEqual(actual.Component3));
+            }
         }
     }
 
@@ -368,9 +406,9 @@ public class JpegColorConverterTests
         float y = values.Component0[i];
         float cb = values.Component1[i];
         float cr = values.Component2[i];
-        var expected = ColorSpaceConverter.ToRgb(new YCbCr(y, cb, cr));
+        Rgb expected = ColorSpaceConverter.ToRgb(new YCbCr(y, cb, cr));
 
-        var actual = new Rgb(result.Component0[i], result.Component1[i], result.Component2[i]);
+        Rgb actual = new(result.Component0[i], result.Component1[i], result.Component2[i]);
 
         bool equal = ColorSpaceComparer.Equals(expected, actual);
         Assert.True(equal, $"Colors {expected} and {actual} are not equal at index {i}");