WIP

TUnit.Core/UntypedDiscoveredTest.cs

@@ -7,6 +7,8 @@
 namespace TUnit.Core;
 
 [UnconditionalSuppressMessage("Trimming", "IL2072:Target parameter argument does not satisfy \'DynamicallyAccessedMembersAttribute\' in call to target method. The return value of the source method does not have matching annotations.")]
+[UnconditionalSuppressMessage("Trimming", "IL2060:Call to \'System.Reflection.MethodInfo.MakeGenericMethod\' can not be statically analyzed. It\'s not possible to guarantee the availability of requirements of the generic method.")]
+[UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with \'RequiresDynamicCodeAttribute\' may break functionality when AOT compiling.")]
 internal record UntypedDiscoveredTest(ResettableLazy<object> ResettableLazy) : DiscoveredTest
 {
     public override async ValueTask ExecuteTest(CancellationToken cancellationToken)

TUnit.Engine/Services/ReflectionScanner.cs

@@ -22,7 +22,7 @@ public static HashSet<Type> GetTypes()
                     return e.Types.OfType<Type>();
                 }
             })
-            .Where(x => x.Name == "MethodDataSourceDrivenTests")
+            .Where(x => x.Name == "GenericMethodTests")
             .ToHashSet();
     }
 }

TUnit.Engine/Services/ReflectionTestsConstructor.cs

@@ -196,14 +196,7 @@ private static void BuildTests(Type type, Func<object?[]> classInstanceArguments
 
                     if (testMethod.ContainsGenericParameters)
                     {
-                        var testParametersTypes = testInformation.Parameters.Select(p => p.Type).ToList();
-
-                        var substitutedTypes = testMethod.GetGenericArguments()
-                            .Select(pc => testParametersTypes.FindIndex(pt => pt == pc))
-                            .Select(i => testMethodArguments[i]!.GetType())
-                            .ToArray();
-
-                        testMethod = testMethod.MakeGenericMethod(substitutedTypes);
+                        testMethod = GetRuntimeMethod(testMethod, testMethodArguments);
                     }
 
                     testsBuilderDynamicTests.Add(new UntypedDynamicTest(type, testMethod)
@@ -237,6 +230,65 @@ private static void BuildTests(Type type, Func<object?[]> classInstanceArguments
         }
     }
 
+    private static MethodInfo GetRuntimeMethod(MethodInfo methodInfo, object?[] arguments)
+    {
+        if (!methodInfo.IsGenericMethodDefinition)
+        {
+            return methodInfo;
+        }
+
+        var typeArguments = methodInfo.GetGenericArguments();
+
+        var parameters = methodInfo.GetParameters();
+
+        var argumentsTypes = arguments.Select(x => x?.GetType()).ToArray();
+
+        List<Type> substituteTypes = [];
+
+        foreach (var typeArgument in typeArguments)
+        {
+            if (!HasGenericParameter(typeArgument))
+            {
+                substituteTypes.Add(typeArgument);
+                continue;
+            }
+
+            var index = Array.IndexOf(typeArguments, typeArgument);
+
+            if (index < 0 || index >= parameters.Length)
+            {
+                throw new InvalidOperationException($"Generic type parameter '{typeArgument.Name}' not found in method parameters.");
+            }
+
+            var parameterType = parameters[index].ParameterType;
+
+            if (HasGenericParameter(parameterType))
+            {
+                // If the parameter is a generic type parameter, we use the type argument
+                substituteTypes.Add(argumentsTypes[index] ?? throw new InvalidOperationException($"No argument provided for generic type parameter '{typeArgument.Name}' at index {index}."));
+                continue;
+            }
+
+            if (parameterType.IsGenericType && parameterType.GetGenericTypeDefinition() == typeof(Nullable<>))
+            {
+                // If the parameter is a nullable type, we use the underlying type
+                substituteTypes.Add(parameterType.GetGenericArguments()[0]);
+            }
+            else
+            {
+                substituteTypes.Add(parameterType);
+            }
+        }
+
+        return methodInfo.MakeGenericMethod(substituteTypes.ToArray());
+    }
+
+    private static bool HasGenericParameter(Type parameterType)
+    {
+        return parameterType.IsGenericParameter
+            || parameterType.IsGenericType && parameterType.GenericTypeArguments.Any(HasGenericParameter);
+    }
+
     private static void AppendOptionalParameters(ref object?[] arguments, SourceGeneratedParameterInformation[] parameters)
     {
         if (arguments.Length == parameters.Length)