Use RemoteExecutor for composition tests

tests/ImageSharp.Tests/PixelFormats/PixelBlenders/PorterDuffCompositorTests.cs

@@ -1,59 +1,66 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders;
-
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Tests.TestUtilities;
 
-using Xunit;
+namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelBlenders;
 
 public class PorterDuffCompositorTests
 {
     // TODO: Add other modes to compare.
     public static readonly TheoryData<PixelAlphaCompositionMode> CompositingOperators =
-        new TheoryData<PixelAlphaCompositionMode>
+        new()
-            {
+        {
-                PixelAlphaCompositionMode.Src,
+            PixelAlphaCompositionMode.Src,
-                PixelAlphaCompositionMode.SrcAtop,
+            PixelAlphaCompositionMode.SrcAtop,
-                PixelAlphaCompositionMode.SrcOver,
+            PixelAlphaCompositionMode.SrcOver,
-                PixelAlphaCompositionMode.SrcIn,
+            PixelAlphaCompositionMode.SrcIn,
-                PixelAlphaCompositionMode.SrcOut,
+            PixelAlphaCompositionMode.SrcOut,
-                PixelAlphaCompositionMode.Dest,
+            PixelAlphaCompositionMode.Dest,
-                PixelAlphaCompositionMode.DestAtop,
+            PixelAlphaCompositionMode.DestAtop,
-                PixelAlphaCompositionMode.DestOver,
+            PixelAlphaCompositionMode.DestOver,
-                PixelAlphaCompositionMode.DestIn,
+            PixelAlphaCompositionMode.DestIn,
-                PixelAlphaCompositionMode.DestOut,
+            PixelAlphaCompositionMode.DestOut,
-                PixelAlphaCompositionMode.Clear,
+            PixelAlphaCompositionMode.Clear,
-                PixelAlphaCompositionMode.Xor
+            PixelAlphaCompositionMode.Xor
-            };
+        };
 
     [Theory]
     [WithFile(TestImages.Png.PDDest, nameof(CompositingOperators), PixelTypes.Rgba32)]
     public void PorterDuffOutputIsCorrect(TestImageProvider<Rgba32> provider, PixelAlphaCompositionMode mode)
     {
-        var srcFile = TestFile.Create(TestImages.Png.PDSrc);
+        static void RunTest(string providerDump, string alphaMode)
-        using (Image<Rgba32> src = srcFile.CreateRgba32Image())
-        using (Image<Rgba32> dest = provider.GetImage())
         {
-            var options = new GraphicsOptions
+            TestImageProvider<Rgba32> provider
+                = BasicSerializer.Deserialize<TestImageProvider<Rgba32>>(providerDump);
+
+            TestFile srcFile = TestFile.Create(TestImages.Png.PDSrc);
+            using Image<Rgba32> src = srcFile.CreateRgba32Image();
+            using Image<Rgba32> dest = provider.GetImage();
+            GraphicsOptions options = new()
             {
                 Antialias = false,
-                AlphaCompositionMode = mode
+                AlphaCompositionMode = Enum.Parse<PixelAlphaCompositionMode>(alphaMode)
             };
 
-            using (Image<Rgba32> res = dest.Clone(x => x.DrawImage(src, options)))
+            using Image<Rgba32> res = dest.Clone(x => x.DrawImage(src, options));
-            {
+            string combinedMode = alphaMode;
-                string combinedMode = mode.ToString();
-
-                if (combinedMode != "Src" && combinedMode.StartsWith("Src"))
-                {
-                    combinedMode = combinedMode.Substring(3);
-                }
 
-                res.DebugSave(provider, combinedMode);
+            if (combinedMode != "Src" && combinedMode.StartsWith("Src", StringComparison.OrdinalIgnoreCase))
-                res.CompareToReferenceOutput(provider, combinedMode);
+            {
+                combinedMode = combinedMode[3..];
             }
+
+            res.DebugSave(provider, combinedMode);
+            res.CompareToReferenceOutput(provider, combinedMode);
         }
+
+        FeatureTestRunner.RunWithHwIntrinsicsFeature(
+            RunTest,
+            HwIntrinsics.AllowAll | HwIntrinsics.DisableAVX,
+            provider,
+            mode.ToString());
     }
 }

tests/ImageSharp.Tests/TestUtilities/FeatureTesting/FeatureTestRunner.cs

@@ -257,6 +257,52 @@ public static class FeatureTestRunner
         }
     }
 
+    /// <summary>
+    /// Runs the given test <paramref name="action"/> within an environment
+    /// where the given <paramref name="intrinsics"/> features.
+    /// </summary>
+    /// <param name="action">The test action to run.</param>
+    /// <param name="intrinsics">The intrinsics features.</param>
+    /// <param name="arg1">The value to pass as a parameter to the test action.</param>
+    /// <param name="arg2">The second value to pass as a parameter to the test action.</param>
+    public static void RunWithHwIntrinsicsFeature<T>(
+        Action<string, string> action,
+        HwIntrinsics intrinsics,
+        T arg1,
+        string arg2)
+        where T : IXunitSerializable
+    {
+        if (!RemoteExecutor.IsSupported)
+        {
+            return;
+        }
+
+        foreach (KeyValuePair<HwIntrinsics, string> intrinsic in intrinsics.ToFeatureKeyValueCollection())
+        {
+            ProcessStartInfo processStartInfo = new();
+            if (intrinsic.Key != HwIntrinsics.AllowAll)
+            {
+                processStartInfo.Environment[$"COMPlus_{intrinsic.Value}"] = "0";
+
+                RemoteExecutor.Invoke(
+                    action,
+                    BasicSerializer.Serialize(arg1),
+                    arg2,
+                    new RemoteInvokeOptions
+                    {
+                        StartInfo = processStartInfo
+                    })
+                    .Dispose();
+            }
+            else
+            {
+                // Since we are running using the default architecture there is no
+                // point creating the overhead of running the action in a separate process.
+                action(BasicSerializer.Serialize(arg1), arg2);
+            }
+        }
+    }
+
     /// <summary>
     /// Runs the given test <paramref name="action"/> within an environment
     /// where the given <paramref name="intrinsics"/> features.