Fix a bunch of failing tests

Author: AArnott

test/Microsoft.Windows.CsWin32.Tests/COMTests.cs

@@ -341,11 +341,11 @@ public void COMInterfaceWithSupportedOSPlatform(bool netstandard, bool allowMars
 
         if (netstandard)
         {
-            Assert.Contains(iface.AttributeLists, al => IsAttributePresent(al, "SupportedOSPlatform"));
+            Assert.DoesNotContain(iface.AttributeLists, al => IsAttributePresent(al, "SupportedOSPlatform"));
         }
         else
         {
-            Assert.DoesNotContain(iface.AttributeLists, al => IsAttributePresent(al, "SupportedOSPlatform"));
+            Assert.Contains(iface.AttributeLists, al => IsAttributePresent(al, "SupportedOSPlatform"));
         }
     }
 
@@ -395,22 +395,21 @@ public void ReferencesToStructWithFlexibleArrayAreAlwaysPointers()
     [CombinatorialData]
     public void COMInterfaceIIDInterfaceOnAppropriateTFMs(
         bool allowMarshaling,
-        [CombinatorialValues(LanguageVersion.CSharp10, LanguageVersion.CSharp11)] LanguageVersion langVersion,
         [CombinatorialValues("net8.0", "net9.0")] string tfm)
     {
         const string structName = "IEnumBstr";
         this.compilation = this.starterCompilations[tfm];
-        this.parseOptions = this.parseOptions.WithLanguageVersion(langVersion);
+        this.parseOptions = this.parseOptions.WithLanguageVersion(GetLanguageVersionForTfm(tfm) ?? LanguageVersion.Latest);
         this.generator = this.CreateGenerator(DefaultTestGeneratorOptions with { AllowMarshaling = allowMarshaling });
         this.GenerateApi(structName);
 
         BaseTypeDeclarationSyntax type = this.FindGeneratedType(structName).Single();
         IEnumerable<BaseTypeSyntax> actual = type.BaseList?.Types ?? Enumerable.Empty<BaseTypeSyntax>();
         Predicate<BaseTypeSyntax> predicate = t => t.Type.ToString().Contains("IComIID");
 
-        // Static interface members requires C# 11 and .NET 7.
+        // Static interface members requires C# 11 and .NET 7+.
         // And COM *interfaces* are not allowed to have them, so assert we only generate them on structs.
-        if (tfm == "net8.0" && langVersion >= LanguageVersion.CSharp11 && type is StructDeclarationSyntax)
+        if (this.parseOptions.LanguageVersion >= LanguageVersion.CSharp11 && type is StructDeclarationSyntax)
         {
             Assert.Contains(actual, predicate);
         }

test/Microsoft.Windows.CsWin32.Tests/GeneratorTestBase.cs

@@ -26,7 +26,7 @@ public GeneratorTestBase(ITestOutputHelper logger)
 
         this.parseOptions = CSharpParseOptions.Default
             .WithDocumentationMode(DocumentationMode.Diagnose)
-            .WithLanguageVersion(LanguageVersion.CSharp11);
+            .WithLanguageVersion(LanguageVersion.CSharp12);
 
         // set in InitializeAsync
         this.compilation = null!;
@@ -91,14 +91,27 @@ public async ValueTask InitializeAsync()
 
         foreach (string tfm in this.starterCompilations.Keys)
         {
-            if (tfm.StartsWith("net6") || tfm.StartsWith("net7"))
+            if (tfm.StartsWith("netstandard", StringComparison.OrdinalIgnoreCase))
             {
-                AddSymbols("NET5_0_OR_GREATER", "NET6_0_OR_GREATER", "NET6_0");
+                AddSymbols("NETSTANDARD");
+                AddSymbols("NETSTANDARD2_0");
+            }
+            else if (tfm.Contains('.'))
+            {
+                AddSymbols("NET5_0_OR_GREATER");
+                AddSymbols("NET6_0_OR_GREATER");
+                AddSymbols("NET7_0_OR_GREATER");
+                AddSymbols("NET8_0_OR_GREATER");
+                AddSymbols(tfm.Replace('.', '_').ToUpperInvariant());
+            }
+            else
+            {
+                AddSymbols("NETFRAMEWORK");
             }
 
-            if (tfm.StartsWith("net7"))
+            if (tfm.StartsWith("net9"))
             {
-                AddSymbols("NET7_0_OR_GREATER", "NET7_0");
+                AddSymbols("NET9_0_OR_GREATER");
             }
 
             // Guarantee we have at least an empty list of symbols for each TFM.
@@ -154,6 +167,13 @@ protected static bool IsOrContainsExternMethod(MethodDeclarationSyntax method)
         return method.Modifiers.Any(SyntaxKind.ExternKeyword) || method.Body?.Statements.OfType<LocalFunctionStatementSyntax>().Any(f => f.Modifiers.Any(SyntaxKind.ExternKeyword)) is true;
     }
 
+    protected static LanguageVersion? GetLanguageVersionForTfm(string tfm) => tfm switch
+    {
+        "net8.0" => LanguageVersion.CSharp12,
+        "net9.0" => LanguageVersion.CSharp13,
+        _ => null,
+    };
+
     protected static IEnumerable<AttributeSyntax> FindAttribute(SyntaxList<AttributeListSyntax> attributeLists, string name) => attributeLists.SelectMany(al => al.Attributes).Where(a => a.Name.ToString() == name);
 
     protected void GenerateApi(string apiName)

test/Microsoft.Windows.CsWin32.Tests/InlineArrayTests.cs

@@ -13,11 +13,10 @@ public void FixedLengthInlineArray(
         bool allowMarshaling,
         bool multitargetingAPIs,
         [CombinatorialValues("net35", "net472", "net8.0")] string tfm,
-        [CombinatorialValues(/*char*/"RM_PROCESS_INFO", /*custom unmanaged*/"ARRAYDESC")] string api,
-        [CombinatorialValues(LanguageVersion.CSharp8, LanguageVersion.CSharp9)] LanguageVersion langVersion)
+        [CombinatorialValues(/*char*/"RM_PROCESS_INFO", /*custom unmanaged*/"ARRAYDESC")] string api)
     {
         this.compilation = this.starterCompilations[tfm];
-        this.parseOptions = this.parseOptions.WithLanguageVersion(langVersion);
+        this.parseOptions = this.parseOptions.WithLanguageVersion(GetLanguageVersionForTfm(tfm) ?? LanguageVersion.CSharp9);
         this.generator = this.CreateGenerator(new GeneratorOptions { AllowMarshaling = allowMarshaling, MultiTargetingFriendlyAPIs = multitargetingAPIs });
 
         // TODO we need to test

test/Microsoft.Windows.CsWin32.Tests/SourceGeneratorTests.cs

@@ -61,11 +61,11 @@ public async Task MissingSystemMemoryReference_WithGeneratedCode_NetFx472()
     /// Asserts that when targeting a framework that implicitly includes the references we need, no warning is generated.
     /// </summary>
     [Fact]
-    public async Task MissingSystemMemoryReference_WithGeneratedCode_Net60()
+    public async Task MissingSystemMemoryReference_WithGeneratedCode_Net80()
     {
         await new VerifyCS.Test(logger)
         {
-            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net80,
             NativeMethodsTxt = "CreateFile",
         }.RunAsync(TestContext.Current.CancellationToken);
     }
@@ -75,7 +75,8 @@ public async Task Gdi32()
     {
         await new VerifyCS.Test(logger)
         {
-            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net80,
+            LanguageVersion = LanguageVersion.CSharp12,
             NativeMethodsTxt = "gdi32.*",
         }.RunAsync(TestContext.Current.CancellationToken);
     }