fix(core): fill optional params when invoking MethodDataSource via reflection

TUnit.Core/Attributes/TestData/MethodDataSourceAttribute.cs

@@ -196,7 +196,7 @@ public MethodDataSourceAttribute(
                 instance = await GetOrCreateInstanceAsync(dataGeneratorMetadata, targetType);
             }
 
-            methodResult = methodInfo.Invoke(instance, Arguments);
+            methodResult = methodInfo.Invoke(instance, BuildInvokeArgs(methodInfo, Arguments));
         }
         else
         {
@@ -324,6 +324,38 @@ public MethodDataSourceAttribute(
         }
     }
 
+    // MethodInfo.Invoke does not auto-fill optional parameters the way a C# call site does.
+    private static object?[] BuildInvokeArgs(MethodInfo methodInfo, object?[] suppliedArguments)
+    {
+        var parameters = methodInfo.GetParameters();
+        if (parameters.Length <= suppliedArguments.Length)
+        {
+            // Exact match passes through; surplus supplied args are left to Invoke to surface as a mismatch.
+            return suppliedArguments;
+        }
+
+        var args = new object?[parameters.Length];
+        Array.Copy(suppliedArguments, args, suppliedArguments.Length);
+        for (var i = suppliedArguments.Length; i < parameters.Length; i++)
+        {
+            var p = parameters[i];
+            if (p.HasDefaultValue)
+            {
+                args[i] = Type.Missing;
+            }
+            else if (p.ParameterType == typeof(CancellationToken))
+            {
+                args[i] = CancellationToken.None;
+            }
+            else
+            {
+                // Required param missing — fall back so Invoke surfaces the original mismatch.
+                return suppliedArguments;
+            }
+        }
+        return args;
+    }
+
     private static Type[]? GetMemberTypes(IMemberMetadata[]? members)
     {
         if (members == null || members.Length == 0)

TUnit.TestProject/Bugs/5879/Repro.cs

@@ -0,0 +1,41 @@
+using System.Runtime.CompilerServices;
+using TUnit.TestProject.Attributes;
+
+namespace TUnit.TestProject.Bugs._5879;
+
+/// <summary>
+/// Regression test for https://github.com/thomhurst/TUnit/issues/5879.
+///
+/// `[InheritsTests]` derived class extends a generic abstract base whose
+/// `[MethodDataSource]` method has an optional `[EnumeratorCancellation] CancellationToken ct = default`
+/// parameter. Source generation can't emit a `Factory` for this case, so the engine
+/// falls back to <c>MethodDataSourceAttribute.GetDataRowsAsync</c>'s reflection
+/// invoke path. <c>MethodInfo.Invoke</c> does not auto-fill defaults like a C# call
+/// site does, so before the fix the call threw <c>TargetParameterCountException</c>.
+/// </summary>
+[EngineTest(ExpectedResult.Pass)]
+[InheritsTests]
+public class Issue5879Tests : Issue5879AbstractBase<string, string>
+{
+    protected override (string, string) Value => ("test", "test");
+}
+
+public abstract class Issue5879AbstractBase<TInput, TExpected>
+{
+    [Test]
+    [MethodDataSource(nameof(DataSource))]
+    public async ValueTask Reproduce((TInput, TExpected) value)
+    {
+        var (input, expected) = value;
+        await Assert.That(input).IsEquivalentTo(expected);
+    }
+
+    public async IAsyncEnumerable<(TInput, TExpected)> DataSource(
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        yield return Value;
+        await Task.CompletedTask;
+    }
+
+    protected abstract (TInput, TExpected) Value { get; }
+}