Refactor to support any number of parameters with validation

- Replace hardcoded switch statements with dynamic delegate generation using expression trees
- Add parameter count and type validation at setup time (not invocation time)
- Support methods with up to 16 parameters (C# Func<> limit)
- Add comprehensive error handling tests
- Validate type compatibility between handler and method parameters
- Throw ArgumentException with clear messages for mismatches
- Fixes all review comments about silent failures and missing validation

Co-authored-by: JeanMarcMbouma <16613177+JeanMarcMbouma@users.noreply.github.com>

Author: Copilot

src/MockLite.Core/Mock.cs

@@ -100,17 +100,7 @@ public Mock<T> Setup<TResult>(Expression<Func<T, TResult>> expression, Func<TRes
     public Mock<T> Setup<TResult, T1>(Expression<Func<T, TResult>> expression, Func<T1, TResult> handler)
     {
         var (method, args) = ExtractMethod(expression);
-        var parameters = method.GetParameters();
-        
-        // Create a delegate that matches the method signature and extracts only the first parameter
-        Delegate behavior = parameters.Length switch
-        {
-            1 => new Func<T1, TResult>(handler),
-            2 => new Func<T1, object?, TResult>((p1, p2) => handler(p1)),
-            3 => new Func<T1, object?, object?, TResult>((p1, p2, p3) => handler(p1)),
-            _ => new Func<TResult>(() => handler(default(T1)!))
-        };
-        
+        var behavior = CreatePartialHandlerDelegate(method, handler, new[] { typeof(T1) }, typeof(TResult));
         _proxy.Setup(method, args, behavior);
         return this;
     }
@@ -136,16 +126,7 @@ public Mock<T> Setup<TResult, T1>(Expression<Func<T, TResult>> expression, Func<
     public Mock<T> Setup<TResult, T1, T2>(Expression<Func<T, TResult>> expression, Func<T1, T2, TResult> handler)
     {
         var (method, args) = ExtractMethod(expression);
-        var parameters = method.GetParameters();
-        
-        // Create a delegate that matches the method signature and extracts only the first two parameters
-        Delegate behavior = parameters.Length switch
-        {
-            2 => new Func<T1, T2, TResult>(handler),
-            3 => new Func<T1, T2, object?, TResult>((p1, p2, p3) => handler(p1, p2)),
-            _ => new Func<TResult>(() => handler(default(T1)!, default(T2)!))
-        };
-        
+        var behavior = CreatePartialHandlerDelegate(method, handler, new[] { typeof(T1), typeof(T2) }, typeof(TResult));
         _proxy.Setup(method, args, behavior);
         return this;
     }
@@ -172,15 +153,7 @@ public Mock<T> Setup<TResult, T1, T2>(Expression<Func<T, TResult>> expression, F
     public Mock<T> Setup<TResult, T1, T2, T3>(Expression<Func<T, TResult>> expression, Func<T1, T2, T3, TResult> handler)
     {
         var (method, args) = ExtractMethod(expression);
-        var parameters = method.GetParameters();
-        
-        // Create a delegate that matches the method signature and extracts only the first three parameters
-        Delegate behavior = parameters.Length switch
-        {
-            3 => new Func<T1, T2, T3, TResult>(handler),
-            _ => new Func<TResult>(() => handler(default(T1)!, default(T2)!, default(T3)!))
-        };
-        
+        var behavior = CreatePartialHandlerDelegate(method, handler, new[] { typeof(T1), typeof(T2), typeof(T3) }, typeof(TResult));
         _proxy.Setup(method, args, behavior);
         return this;
     }
@@ -460,6 +433,134 @@ private static PropertyInfo ExtractProperty(LambdaExpression expr)
         throw new ArgumentException("Expression must be a property access");
     }
 
+    /// <summary>
+    /// Creates a delegate that wraps a partial handler, extracting only the needed parameters from the method signature.
+    /// </summary>
+    /// <param name="method">The target method being mocked.</param>
+    /// <param name="handler">The handler delegate that receives a subset of parameters.</param>
+    /// <param name="handlerParamTypes">The types of parameters expected by the handler.</param>
+    /// <param name="returnType">The return type of the method.</param>
+    /// <returns>A delegate matching the full method signature that forwards to the partial handler.</returns>
+    private static Delegate CreatePartialHandlerDelegate(MethodInfo method, Delegate handler, Type[] handlerParamTypes, Type returnType)
+    {
+        var methodParams = method.GetParameters();
+        
+        // Validate that the method has at least as many parameters as the handler expects
+        if (methodParams.Length < handlerParamTypes.Length)
+        {
+            throw new ArgumentException(
+                $"The method '{method.Name}' has {methodParams.Length} parameter(s), but the handler expects {handlerParamTypes.Length} parameter(s). " +
+                $"The handler can only receive up to {methodParams.Length} parameter(s).",
+                nameof(handler));
+        }
+        
+        // Validate type compatibility for each handler parameter
+        for (int i = 0; i < handlerParamTypes.Length; i++)
+        {
+            var methodParamType = methodParams[i].ParameterType;
+            var handlerParamType = handlerParamTypes[i];
+            
+            if (!handlerParamType.IsAssignableFrom(methodParamType) && methodParamType != handlerParamType)
+            {
+                throw new ArgumentException(
+                    $"Parameter type mismatch at position {i}: method '{method.Name}' has parameter type '{methodParamType.Name}' " +
+                    $"but handler expects '{handlerParamType.Name}'.",
+                    nameof(handler));
+            }
+        }
+        
+        // If the method has the exact same number of parameters as the handler, just return the handler
+        if (methodParams.Length == handlerParamTypes.Length)
+        {
+            return handler;
+        }
+        
+        // Build parameter expressions for the full method signature
+        var methodParamExpressions = methodParams
+            .Select(p => Expression.Parameter(p.ParameterType, p.Name))
+            .ToArray();
+        
+        // Create expression to invoke the handler with only the first N parameters
+        var handlerConstant = Expression.Constant(handler);
+        var handlerParams = methodParamExpressions.Take(handlerParamTypes.Length).ToArray();
+        var invokeExpression = Expression.Invoke(handlerConstant, handlerParams);
+        
+        // Build the correct Func<> delegate type
+        var delegateTypeArgs = methodParams.Select(p => p.ParameterType).Append(returnType).ToArray();
+        Type delegateType;
+        
+        if (delegateTypeArgs.Length == 1)
+        {
+            // Func<TResult> - only return type
+            delegateType = typeof(Func<>).MakeGenericType(delegateTypeArgs);
+        }
+        else
+        {
+            // Func<T1, ..., TN, TResult>
+            var funcType = delegateTypeArgs.Length switch
+            {
+                2 => typeof(Func<,>),
+                3 => typeof(Func<,,>),
+                4 => typeof(Func<,,,>),
+                5 => typeof(Func<,,,,>),
+                6 => typeof(Func<,,,,,>),
+                7 => typeof(Func<,,,,,,>),
+                8 => typeof(Func<,,,,,,,>),
+                9 => typeof(Func<,,,,,,,,>),
+                10 => typeof(Func<,,,,,,,,,>),
+                11 => typeof(Func<,,,,,,,,,,>),
+                12 => typeof(Func<,,,,,,,,,,,>),
+                13 => typeof(Func<,,,,,,,,,,,,>),
+                14 => typeof(Func<,,,,,,,,,,,,,>),
+                15 => typeof(Func<,,,,,,,,,,,,,,>),
+                16 => typeof(Func<,,,,,,,,,,,,,,,>),
+                17 => typeof(Func<,,,,,,,,,,,,,,,,>),
+                _ => throw new NotSupportedException($"Methods with more than 16 parameters are not supported.")
+            };
+            delegateType = funcType.MakeGenericType(delegateTypeArgs);
+        }
+        
+        // Create the lambda with the correct delegate type
+        var lambdaExpression = Expression.Lambda(delegateType, invokeExpression, methodParamExpressions);
+        
+        return lambdaExpression.Compile();
+    }
+
+    /// <summary>
+    /// Creates an action delegate that wraps a partial handler for OnCall, extracting only the needed parameters.
+    /// </summary>
+    /// <param name="method">The target method being mocked.</param>
+    /// <param name="handler">The handler action that receives a subset of parameters.</param>
+    /// <param name="handlerParamTypes">The types of parameters expected by the handler.</param>
+    private static void ValidateAndSetupOnCall(MethodInfo method, Type[] handlerParamTypes, string parameterName)
+    {
+        var methodParams = method.GetParameters();
+        
+        // Validate that the method has at least as many parameters as the handler expects
+        if (methodParams.Length < handlerParamTypes.Length)
+        {
+            throw new ArgumentException(
+                $"The method '{method.Name}' has {methodParams.Length} parameter(s), but the handler expects {handlerParamTypes.Length} parameter(s). " +
+                $"The handler can only receive up to {methodParams.Length} parameter(s).",
+                parameterName);
+        }
+        
+        // Validate type compatibility for each handler parameter
+        for (int i = 0; i < handlerParamTypes.Length; i++)
+        {
+            var methodParamType = methodParams[i].ParameterType;
+            var handlerParamType = handlerParamTypes[i];
+            
+            if (!handlerParamType.IsAssignableFrom(methodParamType) && methodParamType != handlerParamType)
+            {
+                throw new ArgumentException(
+                    $"Parameter type mismatch at position {i}: method '{method.Name}' has parameter type '{methodParamType.Name}' " +
+                    $"but handler expects '{handlerParamType.Name}'.",
+                    parameterName);
+            }
+        }
+    }
+
     // --- Callback Methods ---
 
     /// <summary>
@@ -613,11 +714,8 @@ public Mock<T> OnCall(Expression<Func<T, object?>> expression, Action handler)
     public Mock<T> OnCall<T1>(Expression<Func<T, object?>> expression, Action<T1> handler)
     {
         var (method, _) = ExtractMethod(expression);
-        _proxy.OnInvocation(method, args =>
-        {
-            if (args.Length >= 1)
-                handler((T1)args[0]!);
-        });
+        ValidateAndSetupOnCall(method, new[] { typeof(T1) }, nameof(handler));
+        _proxy.OnInvocation(method, args => handler((T1)args[0]!));
         return this;
     }
 
@@ -641,11 +739,8 @@ public Mock<T> OnCall<T1>(Expression<Func<T, object?>> expression, Action<T1> ha
     public Mock<T> OnCall<T1, T2>(Expression<Func<T, object?>> expression, Action<T1, T2> handler)
     {
         var (method, _) = ExtractMethod(expression);
-        _proxy.OnInvocation(method, args =>
-        {
-            if (args.Length >= 2)
-                handler((T1)args[0]!, (T2)args[1]!);
-        });
+        ValidateAndSetupOnCall(method, new[] { typeof(T1), typeof(T2) }, nameof(handler));
+        _proxy.OnInvocation(method, args => handler((T1)args[0]!, (T2)args[1]!));
         return this;
     }
 
@@ -671,11 +766,8 @@ public Mock<T> OnCall<T1, T2>(Expression<Func<T, object?>> expression, Action<T1
     public Mock<T> OnCall<T1, T2, T3>(Expression<Func<T, object?>> expression, Action<T1, T2, T3> handler)
     {
         var (method, _) = ExtractMethod(expression);
-        _proxy.OnInvocation(method, args =>
-        {
-            if (args.Length >= 3)
-                handler((T1)args[0]!, (T2)args[1]!, (T3)args[2]!);
-        });
+        ValidateAndSetupOnCall(method, new[] { typeof(T1), typeof(T2), typeof(T3) }, nameof(handler));
+        _proxy.OnInvocation(method, args => handler((T1)args[0]!, (T2)args[1]!, (T3)args[2]!));
         return this;
     }
 
@@ -720,11 +812,8 @@ public Mock<T> OnCall(Expression<Action<T>> expression, Action handler)
     public Mock<T> OnCall<T1>(Expression<Action<T>> expression, Action<T1> handler)
     {
         var method = ExtractVoidMethod(expression);
-        _proxy.OnInvocation(method, args =>
-        {
-            if (args.Length >= 1)
-                handler((T1)args[0]!);
-        });
+        ValidateAndSetupOnCall(method, new[] { typeof(T1) }, nameof(handler));
+        _proxy.OnInvocation(method, args => handler((T1)args[0]!));
         return this;
     }
 
@@ -748,11 +837,8 @@ public Mock<T> OnCall<T1>(Expression<Action<T>> expression, Action<T1> handler)
     public Mock<T> OnCall<T1, T2>(Expression<Action<T>> expression, Action<T1, T2> handler)
     {
         var method = ExtractVoidMethod(expression);
-        _proxy.OnInvocation(method, args =>
-        {
-            if (args.Length >= 2)
-                handler((T1)args[0]!, (T2)args[1]!);
-        });
+        ValidateAndSetupOnCall(method, new[] { typeof(T1), typeof(T2) }, nameof(handler));
+        _proxy.OnInvocation(method, args => handler((T1)args[0]!, (T2)args[1]!));
         return this;
     }
 
@@ -778,11 +864,8 @@ public Mock<T> OnCall<T1, T2>(Expression<Action<T>> expression, Action<T1, T2> h
     public Mock<T> OnCall<T1, T2, T3>(Expression<Action<T>> expression, Action<T1, T2, T3> handler)
     {
         var method = ExtractVoidMethod(expression);
-        _proxy.OnInvocation(method, args =>
-        {
-            if (args.Length >= 3)
-                handler((T1)args[0]!, (T2)args[1]!, (T3)args[2]!);
-        });
+        ValidateAndSetupOnCall(method, new[] { typeof(T1), typeof(T2), typeof(T3) }, nameof(handler));
+        _proxy.OnInvocation(method, args => handler((T1)args[0]!, (T2)args[1]!, (T3)args[2]!));
         return this;
     }