fix: support params and optional parameters

Source/Mockolate.SourceGenerators/Entities/MethodParameter.cs

@@ -11,8 +11,18 @@ public MethodParameter(IParameterSymbol parameterSymbol)
 		Name = SyntaxFacts.GetKeywordKind(parameterSymbol.Name) != SyntaxKind.None ? "@" + parameterSymbol.Name : parameterSymbol.Name;
 		RefKind = parameterSymbol.RefKind;
 		IsNullableAnnotated = parameterSymbol.NullableAnnotation == NullableAnnotation.Annotated;
+		IsParams = parameterSymbol.IsParams;
+		HasExplicitDefaultValue = parameterSymbol.HasExplicitDefaultValue;
+		if (HasExplicitDefaultValue)
+		{
+			ExplicitDefaultValue = SymbolDisplay.FormatPrimitive(parameterSymbol.ExplicitDefaultValue, true, false);
+		}
 	}
 
+	public string? ExplicitDefaultValue { get; }
+	public bool HasExplicitDefaultValue { get; }
+	public bool IsParams { get; }
+
 	public bool IsNullableAnnotated { get; }
 	public Type Type { get; }
 	public string Name { get; }

Source/Mockolate.SourceGenerators/Entities/Helpers.cs → Source/Mockolate.SourceGenerators/Helpers.cs

@@ -1,9 +1,12 @@
 using System.Collections.Immutable;
 using System.Text;
 using Microsoft.CodeAnalysis;
+using Mockolate.SourceGenerators.Entities;
 using Mockolate.SourceGenerators.Internals;
+using Attribute = Mockolate.SourceGenerators.Entities.Attribute;
+using Type = Mockolate.SourceGenerators.Entities.Type;
 
-namespace Mockolate.SourceGenerators.Entities;
+namespace Mockolate.SourceGenerators;
 
 internal static class Helpers
 {

Source/Mockolate.SourceGenerators/Sources/Sources.ForMock.Extensions.cs

@@ -380,6 +380,10 @@ private static void AppendMethodSetup(Class @class, StringBuilder sb, Method met
 				}
 
 				sb.Append(' ').Append(parameter.Name);
+				if (parameter.HasExplicitDefaultValue)
+				{
+					sb.Append(" = null");
+				}
 			}
 
 			sb.Append(")");
@@ -875,6 +879,10 @@ private static void AppendInvokedExtensions(StringBuilder sb, Class @class,
 				}
 
 				sb.Append(' ').Append(parameter.Name);
+				if (parameter.HasExplicitDefaultValue)
+				{
+					sb.Append(" = null");
+				}
 			}
 
 			sb.Append(")");

Source/Mockolate.SourceGenerators/Sources/Sources.ForMock.cs

@@ -200,7 +200,17 @@ private static void AppendMockSubject_BaseClassConstructor(StringBuilder sb, Moc
 		sb.Append("\tpublic MockFor").Append(name).Append("(");
 		foreach (MethodParameter parameter in constructor.Parameters)
 		{
+			if (parameter.IsParams)
+			{
+				sb.Append("params ");
+			}
+
 			sb.Append(parameter.Type.Fullname).Append(' ').Append(parameter.Name);
+			if (parameter.HasExplicitDefaultValue)
+			{
+				sb.Append(" = ").Append(parameter.ExplicitDefaultValue);
+			}
+
 			sb.Append(", ");
 		}
 
@@ -647,7 +657,16 @@ private static void AppendMockSubject_ImplementClass_AddMethod(StringBuilder sb,
 			}
 
 			sb.Append(parameter.RefKind.GetString());
+			if (parameter.IsParams)
+			{
+				sb.Append("params ");
+			}
+
 			sb.Append(parameter.Type.Fullname).Append(' ').Append(parameter.Name);
+			if (parameter.HasExplicitDefaultValue)
+			{
+				sb.Append(" = ").Append(parameter.ExplicitDefaultValue);
+			}
 		}
 
 		sb.Append(')');
@@ -950,7 +969,14 @@ private static void AppendNamedParameter(StringBuilder sb, MethodParameter param
 		sb.Append(parameter.Name);
 		if (parameter.CanBeNullable())
 		{
-			sb.Append(" ?? global::Mockolate.It.IsNull<").Append(parameter.ToNullableType()).Append(">()");
+			if (parameter.HasExplicitDefaultValue)
+			{
+				sb.Append(" ?? global::Mockolate.It.Is<").Append(parameter.ToNullableType()).Append(">(").Append(parameter.ExplicitDefaultValue).Append(")");
+			}
+			else
+			{
+				sb.Append(" ?? global::Mockolate.It.IsNull<").Append(parameter.ToNullableType()).Append(">()");
+			}
 		}
 
 		sb.Append("))");

Tests/Mockolate.SourceGenerators.Tests/Sources/ForMockTests.ImplementClassTests.cs

@@ -1189,6 +1189,90 @@ await That(result.Sources).ContainsKey("MockForIMyServiceExtensions.g.cs").Whose
 				          """).IgnoringNewlineStyle();
 		}
 
+		[Fact]
+		public async Task Methods_ShouldSupportParamsParameters()
+		{
+			GeneratorResult result = Generator
+				.Run("""
+				     using System;
+				     using Mockolate;
+
+				     namespace MyCode;
+				     public class Program
+				     {
+				         public static void Main(string[] args)
+				         {
+				     		_ = Mock.Create<IMyService>();
+				         }
+				     }
+
+				     public interface IMyService
+				     {
+				         void MyMethod1(int a, params int[] b);
+				     }
+				     """);
+
+			await That(result.Sources).ContainsKey("MockForIMyService.g.cs").WhoseValue
+				.Contains("""
+				          public void MyMethod1(int a, params int[] b)
+				          """);
+			await That(result.Sources).ContainsKey("MockForIMyServiceExtensions.g.cs").WhoseValue
+				.Contains("""
+				          		public global::Mockolate.Setup.IVoidMethodSetup<int, int[]> MyMethod1(global::Mockolate.Parameters.IParameter<int>? a, global::Mockolate.Parameters.IParameter<int[]>? b)
+				          		{
+				          			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<int, int[]>("MyCode.IMyService.MyMethod1", new global::Mockolate.Parameters.NamedParameter("a", (global::Mockolate.Parameters.IParameter)(a ?? global::Mockolate.It.IsNull<int>())), new global::Mockolate.Parameters.NamedParameter("b", (global::Mockolate.Parameters.IParameter)(b ?? global::Mockolate.It.IsNull<int[]>())));
+				          			CastToMockRegistrationOrThrow(setup).SetupMethod(methodSetup);
+				          			return methodSetup;
+				          		}
+				          """).IgnoringNewlineStyle().And
+				.Contains("""
+				          		public global::Mockolate.Verify.VerificationResult<MyCode.IMyService> MyMethod1(global::Mockolate.Parameters.IParameter<int>? a, global::Mockolate.Parameters.IParameter<int[]>? b)
+				          			=> CastToMockOrThrow(verifyInvoked).Method("MyCode.IMyService.MyMethod1", new global::Mockolate.Parameters.NamedParameter("a", (global::Mockolate.Parameters.IParameter)(a ?? global::Mockolate.It.IsNull<int>())), new global::Mockolate.Parameters.NamedParameter("b", (global::Mockolate.Parameters.IParameter)(b ?? global::Mockolate.It.IsNull<int[]>())));
+				          """).IgnoringNewlineStyle();
+		}
+
+		[Fact]
+		public async Task Methods_ShouldSupportOptionalParameters()
+		{
+			GeneratorResult result = Generator
+				.Run("""
+				     using System;
+				     using Mockolate;
+
+				     namespace MyCode;
+				     public class Program
+				     {
+				         public static void Main(string[] args)
+				         {
+				     		_ = Mock.Create<IMyService>();
+				         }
+				     }
+
+				     public interface IMyService
+				     {
+				         void MyMethod1(int a, int b = 1, bool? c = null, string d = "default");
+				     }
+				     """);
+
+			await That(result.Sources).ContainsKey("MockForIMyService.g.cs").WhoseValue
+				.Contains("""
+				          public void MyMethod1(int a, int b = 1, bool? c = null, string d = "default")
+				          """);
+			await That(result.Sources).ContainsKey("MockForIMyServiceExtensions.g.cs").WhoseValue
+				.Contains("""
+				          		public global::Mockolate.Setup.IVoidMethodSetup<int, int, bool?, string> MyMethod1(global::Mockolate.Parameters.IParameter<int>? a, global::Mockolate.Parameters.IParameter<int>? b = null, global::Mockolate.Parameters.IParameter<bool?>? c = null, global::Mockolate.Parameters.IParameter<string>? d = null)
+				          		{
+				          			var methodSetup = new global::Mockolate.Setup.VoidMethodSetup<int, int, bool?, string>("MyCode.IMyService.MyMethod1", new global::Mockolate.Parameters.NamedParameter("a", (global::Mockolate.Parameters.IParameter)(a ?? global::Mockolate.It.IsNull<int>())), new global::Mockolate.Parameters.NamedParameter("b", (global::Mockolate.Parameters.IParameter)(b ?? global::Mockolate.It.Is<int>(1))), new global::Mockolate.Parameters.NamedParameter("c", (global::Mockolate.Parameters.IParameter)(c ?? global::Mockolate.It.Is<bool?>(null))), new global::Mockolate.Parameters.NamedParameter("d", (global::Mockolate.Parameters.IParameter)(d ?? global::Mockolate.It.Is<string>("default"))));
+				          			CastToMockRegistrationOrThrow(setup).SetupMethod(methodSetup);
+				          			return methodSetup;
+				          		}
+				          """).IgnoringNewlineStyle().And
+				.Contains("""
+				          		public global::Mockolate.Verify.VerificationResult<MyCode.IMyService> MyMethod1(global::Mockolate.Parameters.IParameter<int>? a, global::Mockolate.Parameters.IParameter<int>? b = null, global::Mockolate.Parameters.IParameter<bool?>? c = null, global::Mockolate.Parameters.IParameter<string>? d = null)
+				          			=> CastToMockOrThrow(verifyInvoked).Method("MyCode.IMyService.MyMethod1", new global::Mockolate.Parameters.NamedParameter("a", (global::Mockolate.Parameters.IParameter)(a ?? global::Mockolate.It.IsNull<int>())), new global::Mockolate.Parameters.NamedParameter("b", (global::Mockolate.Parameters.IParameter)(b ?? global::Mockolate.It.Is<int>(1))), new global::Mockolate.Parameters.NamedParameter("c", (global::Mockolate.Parameters.IParameter)(c ?? global::Mockolate.It.Is<bool?>(null))), new global::Mockolate.Parameters.NamedParameter("d", (global::Mockolate.Parameters.IParameter)(d ?? global::Mockolate.It.Is<string>("default"))));
+				          """).IgnoringNewlineStyle();
+		}
+
 		[Fact]
 		public async Task Properties_MultipleImplementations_ShouldOnlyHaveOneExplicitImplementation()
 		{

Tests/Mockolate.Tests/MatchExtensionsTests.cs

@@ -17,6 +17,7 @@ public async Task OutParameterMonitor_MultipleMonitors_ShouldAllMonitorValues()
 		mock.MyMethodWithOutParam(out _);
 		mock.MyMethodWithOutParam(out _);
 		mock.MyMethodWithOutParam(out _);
+		mock.MyMethodWithOptionalParameters(5);
 
 		await That(monitor1.Values).IsEqualTo([1, 2, 3,]);
 		await That(monitor2.Values).IsEqualTo([1, 2, 3,]);

Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs

@@ -736,6 +736,38 @@ public async Task WithInParameter_ShouldUseSetup()
 		await That(result).IsEqualTo(3);
 	}
 
+	[Fact]
+	public async Task WithOptionalParameters_ShouldUseOptionalValueWhenNotSet()
+	{
+		IMyService mock = Mock.Create<IMyService>();
+		mock.SetupMock.Method.MyMethodWithOptionalParameters(It.IsAny<int>()).Returns(true);
+
+		bool result1 = mock.MyMethodWithOptionalParameters(5);
+		bool result2 = mock.MyMethodWithOptionalParameters(5, 1);
+		bool result3 = mock.MyMethodWithOptionalParameters(5, c: "bar");
+
+		await That(result1).IsTrue();
+		await That(result2).IsFalse();
+		await That(result3).IsFalse();
+	}
+
+	[Fact]
+	public async Task WithParamsParameters_ShouldUseOptionalValueWhenNotSet()
+	{
+		IMyService mock = Mock.Create<IMyService>();
+		mock.SetupMock.Method.MyMethodWithParams(It.IsAny<int>(), It.Satisfies<bool[]>(x => x.Length > 1)).Returns(true);
+
+		bool result1 = mock.MyMethodWithParams(5);
+		bool result2 = mock.MyMethodWithParams(5, true);
+		bool result3 = mock.MyMethodWithParams(5, true, false);
+		bool result4 = mock.MyMethodWithParams(5, true, false, true);
+
+		await That(result1).IsFalse();
+		await That(result2).IsFalse();
+		await That(result3).IsTrue();
+		await That(result4).IsTrue();
+	}
+
 	[Fact]
 	public async Task WithRefReadonlyParameter_ShouldUseSetup()
 	{

Tests/Mockolate.Tests/TestHelpers/IMyService.cs

@@ -20,6 +20,8 @@ internal interface IMyService
 
 	void MyMethodWithOutParam(out int value);
 	void MyMethodWithRefParam(ref int value);
+	bool MyMethodWithParams(int a, params bool[] flags);
+	bool MyMethodWithOptionalParameters(int a, int b = 0, string c = "foo");
 
 	event EventHandler? MyEvent;