From 334ab8420b7dc9711ec9e94c385ed309f008b87e Mon Sep 17 00:00:00 2001
From: Jevan Saks <jevansa@microsoft.com>
Date: Wed, 7 Oct 2026 11:51:16 -0700
Subject: [PATCH 1/2] Release cached synthetic metadata before test cleanup

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../MetadataCache.cs                          | 16 +++++
 .../Microsoft.Windows.CsWin32.csproj          |  2 +
 .../InteriorPointerTests.cs                   |  3 +
 .../MetadataCacheTests.cs                     | 67 +++++++++++++++++++
 4 files changed, 88 insertions(+)
 create mode 100644 test/Microsoft.Windows.CsWin32.Tests/MetadataCacheTests.cs

diff --git a/src/Microsoft.Windows.CsWin32/MetadataCache.cs b/src/Microsoft.Windows.CsWin32/MetadataCache.cs
index c4d59996..20ae8f3b 100644
--- a/src/Microsoft.Windows.CsWin32/MetadataCache.cs
+++ b/src/Microsoft.Windows.CsWin32/MetadataCache.cs
@@ -40,4 +40,20 @@ internal MetadataFile GetMetadataFile(string path)
             return metadataFile;
         }
     }
+
+    /// <summary>
+    /// Removes a file from the cache and releases its resources once all readers have been returned.
+    /// </summary>
+    /// <param name="path">The path to the metadata file to remove.</param>
+    internal void RemoveMetadataFile(string path)
+    {
+        lock (this.metadataFiles)
+        {
+            if (this.metadataFiles.TryGetValue(path, out MetadataFile? metadataFile))
+            {
+                this.metadataFiles.Remove(path);
+                metadataFile.Dispose();
+            }
+        }
+    }
 }
diff --git a/src/Microsoft.Windows.CsWin32/Microsoft.Windows.CsWin32.csproj b/src/Microsoft.Windows.CsWin32/Microsoft.Windows.CsWin32.csproj
index 590405fe..ededc2d7 100644
--- a/src/Microsoft.Windows.CsWin32/Microsoft.Windows.CsWin32.csproj
+++ b/src/Microsoft.Windows.CsWin32/Microsoft.Windows.CsWin32.csproj
@@ -4,6 +4,7 @@
     <IsPackable>true</IsPackable>
     <TargetFramework>netstandard2.0</TargetFramework>
     <Nullable>enable</Nullable>
+    <NBGV_ThisAssemblyNamespace>$(RootNamespace)</NBGV_ThisAssemblyNamespace>
 
     <!--
       This project builds the Roslyn 5.0 leg of the analyzer (required to use C# 14
@@ -25,6 +26,7 @@
 
   <ItemGroup>
     <Compile Remove="templates\**\*.cs" />
+    <InternalsVisibleTo Include="Microsoft.Windows.CsWin32.Tests" Key="002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Microsoft.Windows.CsWin32.Tests/InteriorPointerTests.cs b/test/Microsoft.Windows.CsWin32.Tests/InteriorPointerTests.cs
index 4b82dcdd..5262110a 100644
--- a/test/Microsoft.Windows.CsWin32.Tests/InteriorPointerTests.cs
+++ b/test/Microsoft.Windows.CsWin32.Tests/InteriorPointerTests.cs
@@ -375,6 +375,9 @@ private void GenerateFromMetadata(string api, bool containsInteriorPointers, boo
         {
             this.generator?.Dispose();
             this.generator = null;
+
+            // Generator disposal returns its reader to the cache; eviction closes the mapped file.
+            MetadataCache.Default.RemoveMetadataFile(metadataPath);
             File.Delete(metadataPath);
         }
     }
diff --git a/test/Microsoft.Windows.CsWin32.Tests/MetadataCacheTests.cs b/test/Microsoft.Windows.CsWin32.Tests/MetadataCacheTests.cs
new file mode 100644
index 00000000..7c06e816
--- /dev/null
+++ b/test/Microsoft.Windows.CsWin32.Tests/MetadataCacheTests.cs
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Windows.CsWin32.Tests;
+
+/// <summary>
+/// Tests the lifetime of cached metadata files and their readers.
+/// </summary>
+public class MetadataCacheTests
+{
+    private static readonly string MetadataPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location!)!, "Windows.Win32.winmd");
+
+    /// <summary>
+    /// Verifies that eviction closes returned readers and allows the same path to be reopened.
+    /// </summary>
+    [Fact]
+    public void RemoveMetadataFileClosesCachedReaders()
+    {
+        MetadataCache cache = new();
+        try
+        {
+            MetadataFile original = cache.GetMetadataFile(MetadataPath);
+            using (MetadataFile.Rental reader = original.GetMetadataReader())
+            {
+                Assert.NotNull(reader.Value);
+            }
+
+            cache.RemoveMetadataFile(MetadataPath);
+            Assert.Throws<InvalidOperationException>(() => original.GetMetadataReader());
+
+            MetadataFile reopened = cache.GetMetadataFile(MetadataPath);
+            Assert.NotSame(original, reopened);
+            using MetadataFile.Rental reopenedReader = reopened.GetMetadataReader();
+            Assert.NotNull(reopenedReader.Value);
+        }
+        finally
+        {
+            cache.RemoveMetadataFile(MetadataPath);
+        }
+    }
+
+    /// <summary>
+    /// Verifies that eviction does not invalidate a reader that has not yet been returned.
+    /// </summary>
+    [Fact]
+    public void RemoveMetadataFilePreservesActiveReaders()
+    {
+        MetadataCache cache = new();
+        try
+        {
+            MetadataFile original = cache.GetMetadataFile(MetadataPath);
+            using MetadataFile.Rental reader = original.GetMetadataReader();
+            MetadataReader metadata = reader.Value;
+            string assemblyName = metadata.GetString(metadata.GetAssemblyDefinition().Name);
+
+            cache.RemoveMetadataFile(MetadataPath);
+
+            Assert.Equal(assemblyName, metadata.GetString(metadata.GetAssemblyDefinition().Name));
+            Assert.Throws<InvalidOperationException>(() => original.GetMetadataReader());
+            Assert.NotSame(original, cache.GetMetadataFile(MetadataPath));
+        }
+        finally
+        {
+            cache.RemoveMetadataFile(MetadataPath);
+        }
+    }
+}

From 7cbc0c4382428bc847549163c5629f7ff686114f Mon Sep 17 00:00:00 2001
From: Jevan Saks <jevansa@microsoft.com>
Date: Wed, 7 Oct 2026 12:03:26 -0700
Subject: [PATCH 2/2] Use only published metadata for interior-pointer tests

Remove synthetic metadata fixtures and their cache cleanup workaround. Retain package-backed buffer cases and exercise friendly handle/output projections on real printer and token APIs.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 .../MetadataCache.cs                          |  16 -
 .../Microsoft.Windows.CsWin32.csproj          |   2 -
 .../InteriorPointerTests.cs                   | 280 ++----------------
 .../MetadataCacheTests.cs                     |  67 -----
 4 files changed, 23 insertions(+), 342 deletions(-)
 delete mode 100644 test/Microsoft.Windows.CsWin32.Tests/MetadataCacheTests.cs

diff --git a/src/Microsoft.Windows.CsWin32/MetadataCache.cs b/src/Microsoft.Windows.CsWin32/MetadataCache.cs
index 20ae8f3b..c4d59996 100644
--- a/src/Microsoft.Windows.CsWin32/MetadataCache.cs
+++ b/src/Microsoft.Windows.CsWin32/MetadataCache.cs
@@ -40,20 +40,4 @@ internal MetadataFile GetMetadataFile(string path)
             return metadataFile;
         }
     }
-
-    /// <summary>
-    /// Removes a file from the cache and releases its resources once all readers have been returned.
-    /// </summary>
-    /// <param name="path">The path to the metadata file to remove.</param>
-    internal void RemoveMetadataFile(string path)
-    {
-        lock (this.metadataFiles)
-        {
-            if (this.metadataFiles.TryGetValue(path, out MetadataFile? metadataFile))
-            {
-                this.metadataFiles.Remove(path);
-                metadataFile.Dispose();
-            }
-        }
-    }
 }
diff --git a/src/Microsoft.Windows.CsWin32/Microsoft.Windows.CsWin32.csproj b/src/Microsoft.Windows.CsWin32/Microsoft.Windows.CsWin32.csproj
index ededc2d7..590405fe 100644
--- a/src/Microsoft.Windows.CsWin32/Microsoft.Windows.CsWin32.csproj
+++ b/src/Microsoft.Windows.CsWin32/Microsoft.Windows.CsWin32.csproj
@@ -4,7 +4,6 @@
     <IsPackable>true</IsPackable>
     <TargetFramework>netstandard2.0</TargetFramework>
     <Nullable>enable</Nullable>
-    <NBGV_ThisAssemblyNamespace>$(RootNamespace)</NBGV_ThisAssemblyNamespace>
 
     <!--
       This project builds the Roslyn 5.0 leg of the analyzer (required to use C# 14
@@ -26,7 +25,6 @@
 
   <ItemGroup>
     <Compile Remove="templates\**\*.cs" />
-    <InternalsVisibleTo Include="Microsoft.Windows.CsWin32.Tests" Key="002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/Microsoft.Windows.CsWin32.Tests/InteriorPointerTests.cs b/test/Microsoft.Windows.CsWin32.Tests/InteriorPointerTests.cs
index 5262110a..d47a8152 100644
--- a/test/Microsoft.Windows.CsWin32.Tests/InteriorPointerTests.cs
+++ b/test/Microsoft.Windows.CsWin32.Tests/InteriorPointerTests.cs
@@ -2,127 +2,10 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 /// <summary>
-/// Tests projections of native buffers that contain borrowed interior pointers.
+/// Tests projections of native buffers using the published Win32 metadata package.
 /// </summary>
 public class InteriorPointerTests : GeneratorTestBase
 {
-    private const string MetadataSource = """
-        using System;
-        using System.Runtime.InteropServices;
-        using Windows.Win32.Foundation.Metadata;
-
-        namespace Windows.Win32.Foundation.Metadata
-        {
-            [AttributeUsage(AttributeTargets.Parameter)]
-            public sealed class ContainsInteriorPointersAttribute : Attribute { }
-
-            [AttributeUsage(AttributeTargets.Parameter)]
-            public sealed class MemorySizeAttribute : Attribute
-            {
-                public short BytesParamIndex { get; set; }
-            }
-
-            [AttributeUsage(AttributeTargets.Parameter)]
-            public sealed class NativeArrayInfoAttribute : Attribute
-            {
-                public short CountParamIndex { get; set; }
-                public int CountConst { get; set; }
-            }
-
-            [AttributeUsage(AttributeTargets.Parameter)]
-            public sealed class ConstAttribute : Attribute { }
-        }
-
-        namespace Windows.Win32.Test
-        {
-            public unsafe struct RECORD
-            {
-                public byte* Value;
-            }
-
-            [UnmanagedFunctionPointer(CallingConvention.Winapi)]
-            public delegate void CALLBACK();
-
-            public static unsafe class Apis
-            {
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void ByteBuffer(
-                    [ContainsInteriorPointers] [Out] byte* buffer, uint capacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void MemorySizedByteBuffer(
-                    [ContainsInteriorPointers] [Out, MemorySize(BytesParamIndex = 1)] byte* buffer,
-                    uint capacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void VoidBuffer(
-                    [ContainsInteriorPointers] [Out, MemorySize(BytesParamIndex = 1)] void* buffer,
-                    uint capacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void RecordBuffer(
-                    [ContainsInteriorPointers] [Out, MemorySize(BytesParamIndex = 1)] RECORD* buffer,
-                    uint capacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void CountedRecordBuffer(
-                    [ContainsInteriorPointers] [Out, NativeArrayInfo(CountParamIndex = 1)] RECORD* buffer,
-                    uint capacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void ConstantRecordBuffer(
-                    [ContainsInteriorPointers] [Out, NativeArrayInfo(CountConst = 1)] RECORD* buffer,
-                    [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void OptionalRecordBuffer(
-                    [ContainsInteriorPointers] [Out, Optional, MemorySize(BytesParamIndex = 1)] RECORD* buffer,
-                    uint capacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void OptionalCapacityBuffer(
-                    [ContainsInteriorPointers] [Out, MemorySize(BytesParamIndex = 1)] byte* buffer,
-                    [In, Out, Optional] uint* capacity, [Out, Optional] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void ConstRecordBuffer(
-                    [ContainsInteriorPointers] [In, Const, MemorySize(BytesParamIndex = 1)] RECORD* buffer,
-                    uint capacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void SingleRecord(
-                    [ContainsInteriorPointers] [Out] RECORD* buffer, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void ScalarBuffer(
-                    [ContainsInteriorPointers] [Out] uint* buffer, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void CallbackBuffer(
-                    [ContainsInteriorPointers] [Out, NativeArrayInfo(CountParamIndex = 1)] CALLBACK* buffer,
-                    uint capacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void MixedBuffers(
-                    [ContainsInteriorPointers] [Out, MemorySize(BytesParamIndex = 1)] void* buffer,
-                    uint capacity, [Out, MemorySize(BytesParamIndex = 3)] byte* ordinaryBuffer,
-                    uint ordinaryCapacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void SharedCapacity(
-                    [ContainsInteriorPointers] [Out, MemorySize(BytesParamIndex = 2)] byte* buffer,
-                    [Out, MemorySize(BytesParamIndex = 2)] byte* ordinaryBuffer,
-                    uint capacity, [Out] uint* written);
-
-                [DllImport("kernel32.dll", ExactSpelling = true)]
-                public static extern void SharedCapacityReversed(
-                    [Out, NativeArrayInfo(CountParamIndex = 2)] RECORD* ordinaryBuffer,
-                    [ContainsInteriorPointers] [Out, NativeArrayInfo(CountParamIndex = 2)] RECORD* buffer,
-                    uint capacity, [Out] uint* written);
-            }
-        }
-        """;
-
     /// <summary>
     /// Initializes a new instance of the <see cref="InteriorPointerTests"/> class.
     /// </summary>
@@ -228,157 +111,40 @@ public void PublishedMetadataBuffersRemainPointers(string api, string bufferName
     }
 
     /// <summary>
-    /// Verifies that the published annotation does not suppress ordinary buffer projections.
+    /// Verifies that annotated real APIs retain friendly handle and scalar output projections.
     /// </summary>
-    /// <param name="allowMarshaling">Whether to enable marshaling.</param>
-    [Theory, CombinatorialData]
-    public void PublishedMetadataUnannotatedBuffersStillUseSpans(bool allowMarshaling)
+    /// <param name="api">The annotated API to generate.</param>
+    /// <param name="handleName">The handle parameter.</param>
+    /// <param name="outputName">The scalar output parameter.</param>
+    [Theory]
+    [InlineData("GetPrinterW", "hPrinter", "pcbNeeded")]
+    [InlineData("GetTokenInformation", "TokenHandle", "ReturnLength")]
+    public void PublishedMetadataOtherParametersRemainFriendly(string api, string handleName, string outputName)
     {
         this.compilation = this.starterCompilations["net8.0"];
-        this.generator = this.CreateGenerator(DefaultTestGeneratorOptions with { AllowMarshaling = allowMarshaling });
-        this.GenerateApi("ReadFile");
-
-        Assert.Contains(this.FindGeneratedMethod("ReadFile"), method =>
-            method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == "lpBuffer"
-                && parameter.Type is GenericNameSyntax { Identifier.ValueText: "Span" }));
-    }
-
-    /// <summary>
-    /// Verifies that annotated buffers retain native pointer types and explicit capacities in every overload.
-    /// </summary>
-    /// <param name="api">The buffer shape to generate.</param>
-    /// <param name="allowMarshaling">Whether to enable marshaling.</param>
-    /// <param name="includePointerOverloads">Whether additional pointer overloads are requested.</param>
-    [Theory, CombinatorialData]
-    public void AnnotatedBuffersRemainPointers(
-        [CombinatorialValues("ByteBuffer", "MemorySizedByteBuffer", "VoidBuffer", "RecordBuffer", "CountedRecordBuffer", "ConstantRecordBuffer", "OptionalRecordBuffer", "OptionalCapacityBuffer", "ConstRecordBuffer", "SingleRecord", "ScalarBuffer", "CallbackBuffer")] string api,
-        bool allowMarshaling,
-        bool includePointerOverloads)
-    {
-        this.GenerateFromMetadata(api, containsInteriorPointers: true, allowMarshaling, includePointerOverloads);
-
-        MethodDeclarationSyntax[] methods = this.FindGeneratedMethod(api).ToArray();
-        Assert.NotEmpty(methods);
-        Assert.All(methods, method =>
-        {
-            ParameterSyntax buffer = Assert.Single(method.ParameterList.Parameters, parameter => parameter.Identifier.ValueText == "buffer");
-            Assert.IsType<PointerTypeSyntax>(buffer.Type);
-            Assert.Empty(buffer.Modifiers);
-            Assert.Equal(api is not ("ConstantRecordBuffer" or "SingleRecord" or "ScalarBuffer"), method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == "capacity"));
-        });
-
-        Assert.Contains(methods, method => !IsOrContainsExternMethod(method)
-            && method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == "written" && parameter.Modifiers.Any(SyntaxKind.OutKeyword)));
-    }
-
-    /// <summary>
-    /// Verifies that ordinary buffer projections remain available when the annotation is absent.
-    /// </summary>
-    /// <param name="api">The buffer shape to generate.</param>
-    /// <param name="allowMarshaling">Whether to enable marshaling.</param>
-    [Theory, CombinatorialData]
-    public void UnannotatedBuffersStillUseSpans(
-        [CombinatorialValues("ByteBuffer", "MemorySizedByteBuffer", "VoidBuffer", "RecordBuffer", "CountedRecordBuffer", "ConstantRecordBuffer", "OptionalRecordBuffer", "OptionalCapacityBuffer", "ConstRecordBuffer")] string api,
-        bool allowMarshaling)
-    {
-        this.GenerateFromMetadata(api, containsInteriorPointers: false, allowMarshaling, includePointerOverloads: false);
-        Assert.Contains(this.FindGeneratedMethod(api), method => method.ParameterList.Parameters.Any(parameter =>
-            parameter.Identifier.ValueText == "buffer"
-            && parameter.Type is GenericNameSyntax { Identifier.ValueText: "Span" or "ReadOnlySpan" }));
-    }
-
-    /// <summary>
-    /// Verifies that unrelated buffers and scalar outputs still receive friendly projections.
-    /// </summary>
-    /// <param name="allowMarshaling">Whether to enable marshaling.</param>
-    /// <param name="includePointerOverloads">Whether additional pointer overloads are requested.</param>
-    [Theory, CombinatorialData]
-    public void OtherParametersRetainFriendlyProjections(bool allowMarshaling, bool includePointerOverloads)
-    {
-        const string Api = "MixedBuffers";
-        this.GenerateFromMetadata(Api, containsInteriorPointers: true, allowMarshaling, includePointerOverloads);
-
-        Assert.All(this.FindGeneratedMethod(Api), method =>
-        {
-            Assert.IsType<PointerTypeSyntax>(Assert.Single(method.ParameterList.Parameters, parameter => parameter.Identifier.ValueText == "buffer").Type);
-            Assert.Contains(method.ParameterList.Parameters, parameter => parameter.Identifier.ValueText == "capacity");
-        });
-        Assert.Contains(this.FindGeneratedMethod(Api), method =>
-            method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == "ordinaryBuffer" && parameter.Type is GenericNameSyntax { Identifier.ValueText: "Span" })
-            && !method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == "ordinaryCapacity"));
-    }
+        this.generator = this.CreateGenerator(DefaultTestGeneratorOptions with { WideCharOnly = false });
+        this.GenerateApi(api);
 
-    /// <summary>
-    /// Verifies that other buffers cannot remove a capacity needed by an annotated pointer buffer.
-    /// </summary>
-    /// <param name="api">The order and size annotation to generate.</param>
-    /// <param name="allowMarshaling">Whether to enable marshaling.</param>
-    [Theory, CombinatorialData]
-    public void SharedCapacitiesRemainExplicit(
-        [CombinatorialValues("SharedCapacity", "SharedCapacityReversed")] string api,
-        bool allowMarshaling)
-    {
-        this.GenerateFromMetadata(api, containsInteriorPointers: true, allowMarshaling, includePointerOverloads: false);
-        Assert.All(this.FindGeneratedMethod(api), method =>
-        {
-            Assert.Contains(method.ParameterList.Parameters, parameter => parameter.Identifier.ValueText == "capacity");
-            Assert.All(method.ParameterList.Parameters.Where(parameter => parameter.Identifier.ValueText is "buffer" or "ordinaryBuffer"), parameter => Assert.IsType<PointerTypeSyntax>(parameter.Type));
-        });
+        Assert.Contains(this.FindGeneratedMethod(api), method =>
+            method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == handleName
+                && parameter.Type is IdentifierNameSyntax { Identifier.ValueText: "SafeHandle" })
+            && method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == outputName
+                && parameter.Modifiers.Any(SyntaxKind.OutKeyword)));
     }
 
     /// <summary>
-    /// Verifies that optional capacities remain explicit while unrelated optional outputs can still be omitted.
+    /// Verifies that the published annotation does not suppress ordinary buffer projections.
     /// </summary>
     /// <param name="allowMarshaling">Whether to enable marshaling.</param>
     [Theory, CombinatorialData]
-    public void OptionalCapacitiesRemainExplicit(bool allowMarshaling)
-    {
-        const string Api = "OptionalCapacityBuffer";
-        this.GenerateFromMetadata(Api, containsInteriorPointers: true, allowMarshaling, includePointerOverloads: false);
-
-        MethodDeclarationSyntax[] methods = this.FindGeneratedMethod(Api).ToArray();
-        Assert.All(methods, method =>
-            Assert.Contains(method.ParameterList.Parameters, parameter => parameter.Identifier.ValueText == "capacity"));
-        Assert.Contains(methods, method =>
-            method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == "capacity" && parameter.Modifiers.Any(SyntaxKind.RefKeyword)));
-        Assert.Contains(methods, method =>
-            !method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == "written"));
-    }
-
-    private void GenerateFromMetadata(string api, bool containsInteriorPointers, bool allowMarshaling, bool includePointerOverloads)
+    public void PublishedMetadataUnannotatedBuffersStillUseSpans(bool allowMarshaling)
     {
         this.compilation = this.starterCompilations["net8.0"];
-        string source = containsInteriorPointers ? MetadataSource : MetadataSource.Replace("[ContainsInteriorPointers]", string.Empty, StringComparison.Ordinal);
-        CSharpCompilation metadataCompilation = CSharpCompilation.Create(
-            "Windows.Win32",
-            [CSharpSyntaxTree.ParseText(source, this.parseOptions)],
-            this.compilation.References,
-            this.compilation.Options);
-        string metadataPath = Path.Combine(Path.GetTempPath(), $"CsWin32-InteriorPointers-{Guid.NewGuid():N}.winmd");
-        try
-        {
-            using (FileStream stream = File.Create(metadataPath))
-            {
-                var result = metadataCompilation.Emit(stream);
-                Assert.True(result.Success, string.Join(Environment.NewLine, result.Diagnostics));
-            }
-
-            GeneratorOptions options = DefaultTestGeneratorOptions with
-            {
-                AllowMarshaling = allowMarshaling,
-                FriendlyOverloads = new() { IncludePointerOverloads = includePointerOverloads },
-            };
-            this.generator = new Generator(metadataPath, null, [], options, this.compilation, this.parseOptions);
-            this.GenerateApi(api);
-        }
-        finally
-        {
-            this.generator?.Dispose();
-            this.generator = null;
+        this.generator = this.CreateGenerator(DefaultTestGeneratorOptions with { AllowMarshaling = allowMarshaling });
+        this.GenerateApi("ReadFile");
 
-            // Generator disposal returns its reader to the cache; eviction closes the mapped file.
-            MetadataCache.Default.RemoveMetadataFile(metadataPath);
-            File.Delete(metadataPath);
-        }
+        Assert.Contains(this.FindGeneratedMethod("ReadFile"), method =>
+            method.ParameterList.Parameters.Any(parameter => parameter.Identifier.ValueText == "lpBuffer"
+                && parameter.Type is GenericNameSyntax { Identifier.ValueText: "Span" }));
     }
 }
diff --git a/test/Microsoft.Windows.CsWin32.Tests/MetadataCacheTests.cs b/test/Microsoft.Windows.CsWin32.Tests/MetadataCacheTests.cs
deleted file mode 100644
index 7c06e816..00000000
--- a/test/Microsoft.Windows.CsWin32.Tests/MetadataCacheTests.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-namespace Microsoft.Windows.CsWin32.Tests;
-
-/// <summary>
-/// Tests the lifetime of cached metadata files and their readers.
-/// </summary>
-public class MetadataCacheTests
-{
-    private static readonly string MetadataPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location!)!, "Windows.Win32.winmd");
-
-    /// <summary>
-    /// Verifies that eviction closes returned readers and allows the same path to be reopened.
-    /// </summary>
-    [Fact]
-    public void RemoveMetadataFileClosesCachedReaders()
-    {
-        MetadataCache cache = new();
-        try
-        {
-            MetadataFile original = cache.GetMetadataFile(MetadataPath);
-            using (MetadataFile.Rental reader = original.GetMetadataReader())
-            {
-                Assert.NotNull(reader.Value);
-            }
-
-            cache.RemoveMetadataFile(MetadataPath);
-            Assert.Throws<InvalidOperationException>(() => original.GetMetadataReader());
-
-            MetadataFile reopened = cache.GetMetadataFile(MetadataPath);
-            Assert.NotSame(original, reopened);
-            using MetadataFile.Rental reopenedReader = reopened.GetMetadataReader();
-            Assert.NotNull(reopenedReader.Value);
-        }
-        finally
-        {
-            cache.RemoveMetadataFile(MetadataPath);
-        }
-    }
-
-    /// <summary>
-    /// Verifies that eviction does not invalidate a reader that has not yet been returned.
-    /// </summary>
-    [Fact]
-    public void RemoveMetadataFilePreservesActiveReaders()
-    {
-        MetadataCache cache = new();
-        try
-        {
-            MetadataFile original = cache.GetMetadataFile(MetadataPath);
-            using MetadataFile.Rental reader = original.GetMetadataReader();
-            MetadataReader metadata = reader.Value;
-            string assemblyName = metadata.GetString(metadata.GetAssemblyDefinition().Name);
-
-            cache.RemoveMetadataFile(MetadataPath);
-
-            Assert.Equal(assemblyName, metadata.GetString(metadata.GetAssemblyDefinition().Name));
-            Assert.Throws<InvalidOperationException>(() => original.GetMetadataReader());
-            Assert.NotSame(original, cache.GetMetadataFile(MetadataPath));
-        }
-        finally
-        {
-            cache.RemoveMetadataFile(MetadataPath);
-        }
-    }
-}