fix: add support for [GenerateGenericTest] on generic classes (#4431) (#4439)

* fix: add support for [GenerateGenericTest] on generic classes (#4431)

## Summary
- Fix generic class handling in reflection mode by supporting [GenerateGenericTest] attribute
- Fix init-only property setters for generic types (UnsafeAccessor doesn't work with open generics)

## Changes
- **ReflectionTestDataCollector.cs**: Handle [GenerateGenericTest] attributes that explicitly specify type arguments for generic test classes
- **TestMetadataGenerator.cs**: Use reflection-based setter for init-only properties on generic types instead of UnsafeAccessor

## Test cases
Added test files in TUnit.TestProject/Bugs/4431/ demonstrating:
- Generic class with [GenerateGenericTest] attribute
- Generic class with [ClassDataSource] property injection
- Various combinations of generic classes/methods with data sources

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: address review feedback - AOT compatibility and snapshot tests

- Replace reflection-based setter for init-only properties on generic types
  with NotSupportedException (AOT-compatible)
- Add missing verified files for GenericPropertyInjection tests
- Add source generator test for generic method with data source

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: thomhurst

TUnit.Core.SourceGenerator.Tests/GenericMethodWithDataSourceTests.Generic_Method_With_MethodDataSource_Should_Generate_Tests.verified.txt

@@ -0,0 +1,81 @@
+using TUnit.Core.SourceGenerator.Tests.Options;
+
+namespace TUnit.Core.SourceGenerator.Tests;
+
+internal class GenericMethodWithDataSourceTests : TestsBase
+{
+    [Test]
+    public Task Generic_Method_With_MethodDataSource_Should_Generate_Tests() => RunTest(Path.Combine(Git.RootDirectory.FullName,
+            "TUnit.TestProject",
+            "Bugs",
+            "4431",
+            "ComprehensiveGenericTests.cs"),
+        async generatedFiles =>
+        {
+            // This test verifies that generic methods with [GenerateGenericTest] AND [MethodDataSource]
+            // generate proper test metadata including both the type instantiations and the data source
+
+            // Find all files related to GenericMethod_With_DataSource
+            var matchingFiles = generatedFiles.Where(f =>
+                f.Contains("GenericMethod_With_DataSource") &&
+                f.Contains("TestSource")).ToList();
+
+            // Debug: output the matching file count
+            await Assert.That(matchingFiles.Count).IsGreaterThanOrEqualTo(1)
+                .Because($"At least one test source should be generated for GenericMethod_With_DataSource. Found {matchingFiles.Count} matching files.");
+
+            // Debug: output if any file contains Int32
+            var hasInt32 = matchingFiles.Any(f => f.Contains("Int32"));
+            var hasDouble = matchingFiles.Any(f => f.Contains("Double"));
+
+            // Debug: Look at ConcreteInstantiations contents
+            foreach (var file in matchingFiles)
+            {
+                if (file.Contains("ConcreteInstantiations"))
+                {
+                    var idx = file.IndexOf("ConcreteInstantiations");
+                    var snippet = file.Substring(idx, Math.Min(500, file.Length - idx));
+                    Console.WriteLine($"[DEBUG] ConcreteInstantiations snippet: {snippet}");
+                }
+            }
+
+            // Find the file WITH concrete instantiations (uses typeof(int) and typeof(double) syntax)
+            var genericMethodWithDataSourceFile = matchingFiles.FirstOrDefault(f =>
+                f.Contains("typeof(int)") && f.Contains("typeof(double)"));
+
+            await Assert.That(genericMethodWithDataSourceFile).IsNotNull()
+                .Because("A test source should be generated for GenericMethod_With_DataSource with concrete type instantiations (int and double)");
+
+            // If we found the file, verify it has both type instantiations
+            if (genericMethodWithDataSourceFile != null)
+            {
+                // Verify it includes the MethodDataSource
+                await Assert.That(genericMethodWithDataSourceFile).Contains("MethodDataSourceAttribute")
+                    .Because("Should include the MethodDataSource attribute in DataSources");
+                await Assert.That(genericMethodWithDataSourceFile).Contains("GetStrings")
+                    .Because("Should reference the GetStrings method");
+            }
+
+            // Look for FullyGeneric_With_DataSources test generation (class+method generic with data source)
+            var fullyGenericFiles = generatedFiles.Where(f =>
+                f.Contains("FullyGeneric_With_DataSources") &&
+                f.Contains("TestSource")).ToList();
+
+            await Assert.That(fullyGenericFiles.Count).IsGreaterThanOrEqualTo(1)
+                .Because("At least one test source should be generated for FullyGeneric_With_DataSources");
+
+            // Find the file with concrete instantiations (uses typeof(int) or typeof(double) syntax)
+            var fullyGenericFile = fullyGenericFiles.FirstOrDefault(f =>
+                f.Contains("ConcreteInstantiations") &&
+                (f.Contains("typeof(int)") || f.Contains("typeof(double)")));
+
+            // Verify it has the data source
+            if (fullyGenericFile != null)
+            {
+                await Assert.That(fullyGenericFile).Contains("MethodDataSourceAttribute")
+                    .Because("Should include the MethodDataSource attribute in DataSources");
+                await Assert.That(fullyGenericFile).Contains("GetBooleans")
+                    .Because("Should reference the GetBooleans method");
+            }
+        });
+}