Add tests for 'DeclareMinimumPrecisionSupport'

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: a62113de-a3b2-457b-abce-70ee666c9e6f

Author: Sergio0694

tests/ComputeSharp.D2D1.Tests/D2D1PixelShaderTests.cs

@@ -9,6 +9,9 @@
 
 #pragma warning disable IDE0044, IDE0059, IDE0161
 
+// Some tests are specifically validating the experimental DeclareMinimumPrecisionSupport option
+#pragma warning disable CMPSEXP0001
+
 [D2DInputCount(0)]
 [D2DGeneratedPixelShaderDescriptor]
 [AutoConstructor]
@@ -710,6 +713,35 @@ public float4 Execute()
             }
         }
 
+        [TestMethod]
+        public void LoadBytecode_DeclareMinimumPrecisionSupportIsAppliedCorrectly()
+        {
+            ReadOnlyMemory<byte> hlslBytecode1 = D2D1PixelShader.LoadBytecode<ReferenceShaderWithDefaultCompileOptions>(out _, out D2D1CompileOptions compileOptions1);
+            ReadOnlyMemory<byte> hlslBytecode2 = D2D1PixelShader.LoadBytecode<ReferenceShaderWithDeclareMinimumPrecisionSupport>(out _, out D2D1CompileOptions compileOptions2);
+
+            Assert.AreEqual(D2D1CompileOptions.Default, compileOptions1);
+            Assert.AreEqual(D2D1CompileOptions.Default | D2D1CompileOptions.DeclareMinimumPrecisionSupport, compileOptions2);
+
+            // Same check as in D2D1ShaderCompilerTests.CompileInvertEffectWithDeclareMinimumPrecisionSupport
+            Assert.AreEqual(hlslBytecode1.Length + 20, hlslBytecode2.Length);
+        }
+
+        [D2DInputCount(1)]
+        [D2DInputSimple(0)]
+        [D2DShaderProfile(D2D1ShaderProfile.PixelShader50)]
+        [D2DCompileOptions(D2D1CompileOptions.Default | D2D1CompileOptions.DeclareMinimumPrecisionSupport)]
+        [D2DGeneratedPixelShaderDescriptor]
+        public readonly partial struct ReferenceShaderWithDeclareMinimumPrecisionSupport : ID2D1PixelShader
+        {
+            public float4 Execute()
+            {
+                float4 color = D2D.GetInput(0);
+                float3 rgb = Hlsl.Saturate(1.0f - color.RGB);
+
+                return new(rgb, 1);
+            }
+        }
+
         [TestMethod]
         public void GetConstantBufferSize_Empty()
         {

tests/ComputeSharp.D2D1.Tests/D2D1ShaderCompilerTests.cs

@@ -1,7 +1,11 @@
 using System;
+using System.Buffers.Binary;
 using ComputeSharp.D2D1.Interop;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
+// These tests are specifically validating the experimental DeclareMinimumPrecisionSupport option
+#pragma warning disable CMPSEXP0001
+
 namespace ComputeSharp.D2D1.Tests;
 
 [TestClass]
@@ -315,4 +319,97 @@ public void CompileShaderWithWarning_Suppressed()
 
         Assert.IsTrue(bytecode.Length > 0);
     }
+
+    [TestMethod]
+    public void CompileInvertEffectWithDeclareMinimumPrecisionSupport()
+    {
+        ReadOnlyMemory<byte> bytecode = D2D1ShaderCompiler.Compile(
+            InvertEffectSource.AsSpan(),
+            "PSMain".AsSpan(),
+            D2D1ShaderProfile.PixelShader40Level93,
+            D2D1CompileOptions.Default);
+
+        ReadOnlyMemory<byte> bytecodeWithRetention = D2D1ShaderCompiler.Compile(
+            InvertEffectSource.AsSpan(),
+            "PSMain".AsSpan(),
+            D2D1ShaderProfile.PixelShader40Level93,
+            D2D1CompileOptions.Default | D2D1CompileOptions.DeclareMinimumPrecisionSupport);
+
+        // The only difference is the appended shader feature info blob: one entry in the table of
+        // blob offsets (4 bytes), the header of the blob (8 bytes), and its payload (8 bytes).
+        Assert.AreEqual(bytecode.Length + 20, bytecodeWithRetention.Length);
+
+        // Compiling succeeds only if D3DSetBlobPart accepted the patched container, and the resulting
+        // bytecode is only usable if the checksum was recomputed over the patched contents.
+        Assert.IsTrue(IsWellFormedDxbcContainer(bytecodeWithRetention.Span));
+    }
+
+    [TestMethod]
+    public void CompileInvertEffectWithDeclareMinimumPrecisionSupportAndNoLinking()
+    {
+        ReadOnlyMemory<byte> bytecode = D2D1ShaderCompiler.Compile(
+            InvertEffectSource.AsSpan(),
+            "PSMain".AsSpan(),
+            D2D1ShaderProfile.PixelShader40Level93,
+            D2D1CompileOptions.Default & ~D2D1CompileOptions.EnableLinking);
+
+        ReadOnlyMemory<byte> bytecodeWithRetention = D2D1ShaderCompiler.Compile(
+            InvertEffectSource.AsSpan(),
+            "PSMain".AsSpan(),
+            D2D1ShaderProfile.PixelShader40Level93,
+            (D2D1CompileOptions.Default & ~D2D1CompileOptions.EnableLinking) | D2D1CompileOptions.DeclareMinimumPrecisionSupport);
+
+        // There is no export function to reach without linking, so the option is ignored
+        CollectionAssert.AreEqual(bytecode.ToArray(), bytecodeWithRetention.ToArray());
+    }
+
+    /// <summary>
+    /// The HLSL source for a simple invert effect, shared by tests comparing compilation options.
+    /// </summary>
+    private const string InvertEffectSource = """
+        #define D2D_INPUT_COUNT 1
+        #define D2D_INPUT0_SIMPLE
+
+        #include "d2d1effecthelpers.hlsli"
+
+        D2D_PS_ENTRY(PSMain)
+        {
+            float4 color = D2DGetInput(0);
+            float3 rgb = saturate(1.0 - color.rgb);
+            return float4(rgb, 1);
+        }
+        """;
+
+    /// <summary>
+    /// Checks that a buffer is a DXBC container with a consistent size and set of blob offsets.
+    /// </summary>
+    /// <param name="bytecode">The DXBC container to inspect.</param>
+    /// <returns>Whether <paramref name="bytecode"/> is a well formed DXBC container.</returns>
+    private static bool IsWellFormedDxbcContainer(ReadOnlySpan<byte> bytecode)
+    {
+        if (bytecode.Length < 32 || !bytecode.StartsWith("DXBC"u8))
+        {
+            return false;
+        }
+
+        if (BinaryPrimitives.ReadUInt32LittleEndian(bytecode.Slice(24)) != (uint)bytecode.Length)
+        {
+            return false;
+        }
+
+        uint blobCount = BinaryPrimitives.ReadUInt32LittleEndian(bytecode.Slice(28));
+
+        for (int i = 0; i < blobCount; i++)
+        {
+            uint blobOffset = BinaryPrimitives.ReadUInt32LittleEndian(bytecode.Slice(32 + (i * 4)));
+            uint blobSize = BinaryPrimitives.ReadUInt32LittleEndian(bytecode.Slice((int)blobOffset + 4));
+
+            if (blobOffset + 8 + blobSize > bytecode.Length)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }