refactor(assertions): enhance collection assertion types for improved type inference and chaining

SourceGenerationDebug.props

@@ -1,8 +1,8 @@
 <Project>
-    <!-- <PropertyGroup>
+    <PropertyGroup>
         <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
         <CompilerGeneratedFilesOutputPath>SourceGeneratedViewer</CompilerGeneratedFilesOutputPath>
-    </PropertyGroup> -->
+    </PropertyGroup>
 
     <ItemGroup>
         <Compile Remove="SourceGeneratedViewer\**" />

TUnit.Assertions.Analyzers.CodeFixers.Tests/Verifiers/CSharpCodeFixVerifier`2.cs

@@ -12,6 +12,18 @@ public static partial class CSharpCodeFixVerifier<TAnalyzer, TCodeFix>
     where TAnalyzer : DiagnosticAnalyzer, new()
     where TCodeFix : CodeFixProvider, new()
 {
+    private static ReferenceAssemblies GetReferenceAssemblies()
+    {
+#if NET472
+        return ReferenceAssemblies.NetFramework.Net472.Default;
+#elif NET8_0
+        return ReferenceAssemblies.Net.Net80;
+#elif NET9_0 || NET10_0_OR_GREATER
+        return ReferenceAssemblies.Net.Net90;
+#else
+        return ReferenceAssemblies.Net.Net80; // Default fallback
+#endif
+    }
     /// <inheritdoc cref="Microsoft.CodeAnalysis.Diagnostic"/>
     public static DiagnosticResult Diagnostic()
         => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, DefaultVerifier>.Diagnostic();
@@ -33,7 +45,7 @@ params DiagnosticResult[] expected
         {
             TestCode = source.NormalizeLineEndings(),
             CodeActionValidationMode = CodeActionValidationMode.SemanticStructure,
-            ReferenceAssemblies = ReferenceAssemblies.Net.Net90
+            ReferenceAssemblies = GetReferenceAssemblies()
                 .AddPackages([new PackageIdentity("xunit.v3.assert", "2.0.0")]),
             TestState =
             {
@@ -68,7 +80,7 @@ public static async Task VerifyCodeFixAsync(
         {
             TestCode = source.NormalizeLineEndings(),
             FixedCode = fixedSource.NormalizeLineEndings(),
-            ReferenceAssemblies = ReferenceAssemblies.Net.Net90
+            ReferenceAssemblies = GetReferenceAssemblies()
                 .AddPackages([new PackageIdentity("xunit.v3.assert", "2.0.0")]),
             TestState =
             {

TUnit.Assertions.Analyzers.Tests/Verifiers/CSharpAnalyzerVerifier`1.cs

@@ -9,6 +9,18 @@ namespace TUnit.Assertions.Analyzers.Tests.Verifiers;
 public static partial class CSharpAnalyzerVerifier<TAnalyzer>
     where TAnalyzer : DiagnosticAnalyzer, new()
 {
+    private static ReferenceAssemblies GetReferenceAssemblies()
+    {
+#if NET472
+        return ReferenceAssemblies.NetFramework.Net472.Default;
+#elif NET8_0
+        return ReferenceAssemblies.Net.Net80;
+#elif NET9_0 || NET10_0_OR_GREATER
+        return ReferenceAssemblies.Net.Net90;
+#else
+        return ReferenceAssemblies.Net.Net80; // Default fallback
+#endif
+    }
     /// <inheritdoc cref="Microsoft.CodeAnalysis.Diagnostic"/>
     public static DiagnosticResult Diagnostic()
         => CSharpAnalyzerVerifier<TAnalyzer, DefaultVerifier>.Diagnostic();
@@ -27,7 +39,7 @@ public static async Task VerifyAnalyzerAsync([StringSyntax("c#-test")] string so
         var test = new Test
         {
             TestCode = source,
-            ReferenceAssemblies = ReferenceAssemblies.Net.Net90
+            ReferenceAssemblies = GetReferenceAssemblies()
                 .AddPackages([new PackageIdentity("xunit.v3.assert", "2.0.0")]),
             TestState =
             {

TUnit.Assertions.SourceGenerator.Tests/ArrayAssertionGeneratorTests.cs

@@ -13,6 +13,6 @@ public Task GeneratesArrayAssertions() => RunTest(
             "ArrayAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/AssemblyAssertionGeneratorTests.cs

@@ -12,6 +12,6 @@ public Task GeneratesAssemblyAssertions() => RunTest(
             "AssemblyAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/AssertionExtensionGeneratorTests.cs

@@ -13,7 +13,7 @@ public Task NonGenericAssertion() => RunTest(
             "NonGenericAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("IsEmpty"));
             await Assert.That(extensionFile).IsNotNull();
             await Assert.That(extensionFile!).Contains("IsEmpty");
@@ -27,7 +27,7 @@ public Task SingleGenericParameter() => RunTest(
             "SingleGenericParameterAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("IsNull"));
             await Assert.That(extensionFile).IsNotNull();
             await Assert.That(extensionFile!).Contains("IsNull");
@@ -42,7 +42,7 @@ public Task MultipleGenericParameters() => RunTest(
             "MultipleGenericParametersAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("IsAssignableTo"));
             await Assert.That(extensionFile).IsNotNull();
             await Assert.That(extensionFile!).Contains("IsAssignableTo");
@@ -57,7 +57,7 @@ public Task AssertionWithOptionalParameter() => RunTest(
             "OptionalParameterAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("IsNotEqualTo"));
             await Assert.That(extensionFile).IsNotNull();
             await Assert.That(extensionFile!).Contains("IsNotEqualTo");
@@ -72,7 +72,7 @@ public Task AssertionWithGenericConstraints() => RunTest(
             "GenericConstraintsAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("IsGreaterThan"));
             await Assert.That(extensionFile).IsNotNull();
             await Assert.That(extensionFile!).Contains("IsGreaterThan");
@@ -87,7 +87,7 @@ public Task AssertionWithMultipleConstructors() => RunTest(
             "MultipleConstructorsAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("IsEqualTo"));
             await Assert.That(extensionFile).IsNotNull();
             // Should generate multiple overloads
@@ -103,7 +103,7 @@ public Task AssertionWithNegatedMethod() => RunTest(
             "NegatedMethodAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("IsTrue"));
             await Assert.That(extensionFile).IsNotNull();
             await Assert.That(extensionFile!).Contains("IsTrue");
@@ -118,7 +118,7 @@ public Task AssertionWithDefaultValues() => RunTest(
             "DefaultValuesAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("= true"));
             await Assert.That(extensionFile).IsNotNull();
             await Assert.That(extensionFile!).Contains("= true");
@@ -134,7 +134,7 @@ public Task AssertionWithEnumDefault() => RunTest(
             "EnumDefaultAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("StringComparison"));
             await Assert.That(extensionFile).IsNotNull();
             await Assert.That(extensionFile!).Contains("StringComparison.");
@@ -148,7 +148,7 @@ public Task AssertionWithMultipleParameters() => RunTest(
             "MultipleParametersAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
             var extensionFile = generatedFiles.FirstOrDefault(f => f.Contains("IsBetween"));
             await Assert.That(extensionFile).IsNotNull();
             await Assert.That(extensionFile!).Contains("IsBetween");

TUnit.Assertions.SourceGenerator.Tests/BooleanAssertionGeneratorTests.cs

@@ -13,6 +13,6 @@ public Task GeneratesBooleanAssertions() => RunTest(
             "BooleanAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/CancellationTokenAssertionGeneratorTests.cs

@@ -12,6 +12,6 @@ public Task GeneratesCancellationTokenAssertions() => RunTest(
             "CancellationTokenAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/CharAssertionGeneratorTests.cs

@@ -12,6 +12,6 @@ public Task GeneratesCharAssertions() => RunTest(
             "CharAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/CultureInfoAssertionGeneratorTests.cs

@@ -12,6 +12,6 @@ public Task GeneratesCultureInfoAssertions() => RunTest(
             "CultureInfoAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/DateOnlyAssertionGeneratorTests.cs

@@ -13,6 +13,6 @@ public Task GeneratesDateOnlyAssertions() => RunTest(
             "DateOnlyAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(0);
+            await Assert.That(generatedFiles).HasCount(0);
         });
 }

TUnit.Assertions.SourceGenerator.Tests/DateTimeAssertionGeneratorTests.cs

@@ -12,6 +12,6 @@ public Task GeneratesDateTimeAssertions() => RunTest(
             "DateTimeAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/DateTimeOffsetAssertionGeneratorTests.cs

@@ -13,6 +13,6 @@ public Task GeneratesDateTimeOffsetAssertions() => RunTest(
             "DateTimeOffsetAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/DayOfWeekAssertionGeneratorTests.cs

@@ -13,6 +13,6 @@ public Task GeneratesDayOfWeekAssertions() => RunTest(
             "DayOfWeekAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/DirectoryInfoAssertionGeneratorTests.cs

@@ -12,6 +12,6 @@ public Task GeneratesDirectoryInfoAssertions() => RunTest(
             "DirectoryInfoAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/EncodingAssertionGeneratorTests.cs

@@ -12,6 +12,6 @@ public Task GeneratesEncodingAssertions() => RunTest(
             "EncodingAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/ExceptionAssertionGeneratorTests.cs

@@ -13,6 +13,6 @@ public Task GeneratesExceptionAssertions() => RunTest(
             "ExceptionAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/FileInfoAssertionGeneratorTests.cs

@@ -12,6 +12,6 @@ public Task GeneratesFileInfoAssertions() => RunTest(
             "FileInfoAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/GuidAssertionGeneratorTests.cs

@@ -13,6 +13,6 @@ public Task GeneratesGuidAssertions() => RunTest(
             "GuidAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/HttpStatusCodeAssertionGeneratorTests.cs

@@ -13,6 +13,6 @@ public Task GeneratesHttpStatusCodeAssertions() => RunTest(
             "HttpStatusCodeAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/LazyAssertionGeneratorTests.cs

@@ -13,6 +13,6 @@ public Task GeneratesLazyAssertions() => RunTest(
             "LazyAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }

TUnit.Assertions.SourceGenerator.Tests/MethodAssertionGeneratorTests.cs

@@ -13,7 +13,7 @@ public Task BoolMethod() => RunTest(
             "BoolMethodAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.FirstOrDefault(f => f.Contains("IsPositive_Assertion"));
             await Assert.That(mainFile).IsNotNull();
@@ -30,7 +30,7 @@ public Task AssertionResultMethod() => RunTest(
             "AssertionResultMethodAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.FirstOrDefault(f => f.Contains("IsEven_Assertion"));
             await Assert.That(mainFile).IsNotNull();
@@ -47,7 +47,7 @@ public Task AsyncBoolMethod() => RunTest(
             "AsyncBoolAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.FirstOrDefault(f => f.Contains("IsPositiveAsync_Assertion"));
             await Assert.That(mainFile).IsNotNull();
@@ -63,7 +63,7 @@ public Task AsyncAssertionResultMethod() => RunTest(
             "AsyncAssertionResultAssertion.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.FirstOrDefault(f => f.Contains("IsEvenAsync_Assertion"));
             await Assert.That(mainFile).IsNotNull();
@@ -79,7 +79,7 @@ public Task GenericMethodWithNonInferableTypeParameter() => RunTest(
             "GenericMethodWithNonInferableTypeParameter.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.FirstOrDefault(f => f.Contains("IsErrorOfType"));
             await Assert.That(mainFile).IsNotNull();
@@ -99,7 +99,7 @@ public Task MethodWithComparableConstraint() => RunTest(
             "MethodWithComparableConstraint.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.First();
             await Assert.That(mainFile).IsNotNull();
@@ -122,7 +122,7 @@ public Task MethodWithMultipleConstraints() => RunTest(
             "MethodWithMultipleConstraints.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.First();
             await Assert.That(mainFile).IsNotNull();
@@ -141,7 +141,7 @@ public Task MethodWithReferenceTypeConstraint() => RunTest(
             "MethodWithReferenceTypeConstraint.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.First();
             await Assert.That(mainFile).IsNotNull();
@@ -160,7 +160,7 @@ public Task MethodWithValueTypeConstraint() => RunTest(
             "MethodWithValueTypeConstraint.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.First();
             await Assert.That(mainFile).IsNotNull();
@@ -179,7 +179,7 @@ public Task MethodWithNotNullConstraint() => RunTest(
             "MethodWithNotNullConstraint.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().EqualTo(1);
+            await Assert.That(generatedFiles).HasCount(1);
 
             var mainFile = generatedFiles.First();
             await Assert.That(mainFile).IsNotNull();

TUnit.Assertions.SourceGenerator.Tests/ProcessAssertionGeneratorTests.cs

@@ -12,6 +12,6 @@ public Task GeneratesProcessAssertions() => RunTest(
             "ProcessAssertionExtensions.cs"),
         async generatedFiles =>
         {
-            await Assert.That(generatedFiles).HasCount().GreaterThanOrEqualTo(1);
+            await Assert.That(generatedFiles).IsNotEmpty();
         });
 }