Skip to content

fix: support params and optional parameters #520

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
vbreuss merged 4 commits into from
Mar 7, 2026
Merged

fix: support params and optional parameters #520

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
c5fe443
fix: support `params` and optional parameters
vbreuss Mar 7, 2026
4acd340
Also support optional parameters in constructors
vbreuss Mar 7, 2026
fc6c88a
Fix review issues
vbreuss Mar 7, 2026
ae49f06
Fix indentation
vbreuss Mar 7, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 22 additions & 1 deletion Source/Mockolate.SourceGenerators/Entities/MethodParameter.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,11 +8,32 @@ internal readonly record struct MethodParameter
public MethodParameter(IParameterSymbol parameterSymbol)
{
Type = new Type(parameterSymbol.Type);
Name = SyntaxFacts.GetKeywordKind(parameterSymbol.Name) != SyntaxKind.None ? "@" + parameterSymbol.Name : parameterSymbol.Name;
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)
{
var explicitDefaultValue = SymbolDisplay.FormatPrimitive(parameterSymbol.ExplicitDefaultValue, true, false);
if (parameterSymbol.Type.TypeKind == TypeKind.Enum)
{
string enumTypeName = parameterSymbol.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
ExplicitDefaultValue = "(" + enumTypeName + ")" + explicitDefaultValue;
}
else
{
ExplicitDefaultValue = explicitDefaultValue;
}
}
}

public string? ExplicitDefaultValue { get; }
public bool HasExplicitDefaultValue { get; }
public bool IsParams { get; }

public bool IsNullableAnnotated { get; }
public Type Type { get; }
public string Name { get; }
Expand Down
5 changes: 4 additions & 1 deletion ...late.SourceGenerators/Entities/Helpers.cs → Source/Mockolate.SourceGenerators/Helpers.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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
{
Expand Down
8 changes: 8 additions & 0 deletions Source/Mockolate.SourceGenerators/Sources/Sources.ForMock.Extensions.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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(")");
Expand Down Expand Up @@ -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(")");
Expand Down
34 changes: 30 additions & 4 deletions Source/Mockolate.SourceGenerators/Sources/Sources.ForMock.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -197,14 +197,24 @@ private static void AppendMockSubject_BaseClassConstructor(StringBuilder sb, Moc
{
sb.Append("\t/// <inheritdoc cref=\"MockFor").Append(name).Append("\" />").AppendLine();
sb.Append(constructor.Attributes, "\t");
sb.Append("\tpublic MockFor").Append(name).Append("(");
sb.Append("\tpublic MockFor").Append(name).Append("(global::Mockolate.MockRegistration mockRegistration");
foreach (MethodParameter parameter in constructor.Parameters)
{
sb.Append(parameter.Type.Fullname).Append(' ').Append(parameter.Name);
sb.Append(", ");
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("global::Mockolate.MockRegistration mockRegistration)").AppendLine();
sb.Append(")").AppendLine();
sb.Append("\t\t\t: base(");
int index = 0;
foreach (MethodParameter parameter in constructor.Parameters)
Expand Down Expand Up @@ -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 (!explicitInterfaceImplementation && parameter.HasExplicitDefaultValue)
{
sb.Append(" = ").Append(parameter.ExplicitDefaultValue);
}
}

sb.Append(')');
Expand Down Expand Up @@ -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("))");
Expand Down
39 changes: 31 additions & 8 deletions Source/Mockolate.SourceGenerators/Sources/Sources.MockRegistration.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -169,14 +169,25 @@ namespace Mockolate;
.Select(constructor => constructor.Parameters))
{
constructorIndex++;
sb.Append("\t\t\t\telse if (constructorParameters.Parameters.Length == ")
.Append(constructorParameters.Count);
int requiredParameters = constructorParameters.Count(c => !c.HasExplicitDefaultValue);
if (requiredParameters < constructorParameters.Count)
{
sb.Append("\t\t\t\telse if (constructorParameters.Parameters.Length >= ")
.Append(requiredParameters);
}
else
{
sb.Append("\t\t\t\telse if (constructorParameters.Parameters.Length == ")
.Append(constructorParameters.Count);
}
Comment thread
vbreuss marked this conversation as resolved.

int constructorParameterIndex = 0;
foreach (MethodParameter parameter in constructorParameters)
{
sb.AppendLine().Append("\t\t\t\t && TryCast(constructorParameters.Parameters[")
sb.AppendLine().Append("\t\t\t\t && TryCast(constructorParameters.Parameters, ")
.Append(constructorParameterIndex++)
.Append("], mockBehavior, out ").Append(parameter.Type.Fullname).Append(" c")
.Append(parameter.HasExplicitDefaultValue ? $", {parameter.ExplicitDefaultValue}" : "")
.Append(", mockBehavior, out ").Append(parameter.Type.Fullname).Append(" c")
.Append(constructorIndex)
.Append('p')
.Append(constructorParameterIndex).Append(")");
Expand All @@ -201,13 +212,13 @@ namespace Mockolate;
sb.Append("\t\t\t\t\t\t\tsetup.Invoke(setupTarget);").AppendLine();
sb.Append("\t\t\t\t\t\t}").AppendLine();
sb.Append("\t\t\t\t\t}").AppendLine();
sb.Append("\t\t\t\t\t_value = new global::Mockolate.Generated.MockFor").Append(mock.Name).Append("(");
sb.Append("\t\t\t\t\t_value = new global::Mockolate.Generated.MockFor").Append(mock.Name).Append("(mockRegistration");
for (int i = 1; i <= constructorParameters.Count; i++)
{
sb.Append('c').Append(constructorIndex).Append('p').Append(i).Append(", ");
sb.Append(", ").Append('c').Append(constructorIndex).Append('p').Append(i);
}

sb.Append("mockRegistration);").AppendLine();
sb.Append(");").AppendLine();
sb.Append("\t\t\t\t}").AppendLine();
}

Expand Down Expand Up @@ -284,8 +295,9 @@ namespace Mockolate;
}

sb.Append("""
private static bool TryCast<TValue>(object? value, global::Mockolate.MockBehavior behavior, out TValue result)
private static bool TryCast<TValue>(object?[] values, int index, global::Mockolate.MockBehavior behavior, out TValue result)
{
var value = values[index];
if (value is TValue typedValue)
{
result = typedValue;
Expand All @@ -295,6 +307,17 @@ private static bool TryCast<TValue>(object? value, global::Mockolate.MockBehavio
result = default!;
return value is null;
}
private static bool TryCast<TValue>(object?[] values, int index, TValue defaultValue, global::Mockolate.MockBehavior behavior, out TValue result)
{
if (values.Length > index && values[index] is TValue typedValue)
{
result = typedValue;
return true;
}

result = defaultValue;
return true;
Comment thread
vbreuss marked this conversation as resolved.
Comment on lines +313 to +320
Copy link

Copilot AI Mar 7, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This TryCast overload returns true even when an argument is present at index but is not of type TValue (it falls through and uses defaultValue). That can make WithConstructorParameters(...) silently accept the wrong argument types and pick the wrong constructor. Consider only using defaultValue when values.Length <= index; if values[index] exists but isn’t TValue (and isn’t an allowed null), return false like the non-default overload.

Suggested change
if (values.Length > index && values[index] is TValue typedValue)
{
result = typedValue;
return true;
}
result = defaultValue;
return true;
if (values.Length <= index)
{
result = defaultValue;
return true;
}
var value = values[index];
if (value is TValue typedValue)
{
result = typedValue;
return true;
}
result = default!;
return value is null;

Copilot uses AI. Check for mistakes.
}
""").AppendLine();
sb.AppendLine("}");
sb.AppendLine("#nullable disable");
Expand Down
2 changes: 1 addition & 1 deletion Tests/Mockolate.SourceGenerators.Tests/GeneralTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -411,7 +411,7 @@ public MockForMyBaseClass(global::Mockolate.MockRegistration mockRegistration)
""").IgnoringNewlineStyle().And
.Contains("""
[System.Obsolete("This constructor is obsolete")]
public MockForMyBaseClass(int value, global::Mockolate.MockRegistration mockRegistration)
public MockForMyBaseClass(global::Mockolate.MockRegistration mockRegistration, int value)
""").IgnoringNewlineStyle().And
.Contains("""
[System.Obsolete("This event is obsolete")]
Expand Down
84 changes: 84 additions & 0 deletions Tests/Mockolate.SourceGenerators.Tests/Sources/ForMockTests.ImplementClassTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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()
{
Expand Down
8 changes: 4 additions & 4 deletions Tests/Mockolate.SourceGenerators.Tests/Sources/ForMockTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -74,7 +74,7 @@ await That(result.Sources).ContainsKey("MockRegistration.g.cs").WhoseValue
setup.Invoke(setupTarget);
}
}
_value = new global::Mockolate.Generated.MockForMyBaseClass(c1p1, mockRegistration);
_value = new global::Mockolate.Generated.MockForMyBaseClass(mockRegistration, c1p1);
}
""".TrimStart()).IgnoringNewlineStyle().And
.Contains("""
Expand All @@ -94,7 +94,7 @@ await That(result.Sources).ContainsKey("MockRegistration.g.cs").WhoseValue
setup.Invoke(setupTarget);
}
}
_value = new global::Mockolate.Generated.MockForMyBaseClass(c2p1, c2p2, mockRegistration);
_value = new global::Mockolate.Generated.MockForMyBaseClass(mockRegistration, c2p1, c2p2);
}
""".TrimStart()).IgnoringNewlineStyle().And
.Contains("""
Expand All @@ -106,15 +106,15 @@ await That(result.Sources).ContainsKey("MockRegistration.g.cs").WhoseValue

await That(result.Sources).ContainsKey("MockForMyBaseClass.g.cs").WhoseValue
.Contains("""
public MockForMyBaseClass(int value, global::Mockolate.MockRegistration mockRegistration)
public MockForMyBaseClass(global::Mockolate.MockRegistration mockRegistration, int value)
: base(value)
{
_mock = new global::Mockolate.Mock<MyCode.MyBaseClass>(this, mockRegistration, new object?[] { value });
_mockRegistrations = mockRegistration;
}
""").IgnoringNewlineStyle().And
.Contains("""
public MockForMyBaseClass(int value, bool flag, global::Mockolate.MockRegistration mockRegistration)
public MockForMyBaseClass(global::Mockolate.MockRegistration mockRegistration, int value, bool flag)
: base(value, flag)
{
_mock = new global::Mockolate.Mock<MyCode.MyBaseClass>(this, mockRegistration, new object?[] { value, flag });
Expand Down
44 changes: 44 additions & 0 deletions Tests/Mockolate.Tests/BaseClassTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,4 +33,48 @@ public async Task WithConstructorParameters_WithNull_ShouldReturnArrayWithNullEl

await That(result.Parameters).HasSingle().Which.IsNull();
}

[Fact]
public async Task WithOptionalParameters_ShouldUseDefaultValues()
{
MyBaseClass mock = Mock.Create<MyBaseClass>(BaseClass.WithConstructorParameters(1));

await That(mock.A).IsEqualTo(1);
await That(mock.B).IsEqualTo(2);
await That(mock.C).IsEqualTo("foo");
}

[Fact]
public async Task WithOptionalParameters_WithAllExplicitValues_ShouldUseExplicitValues()
{
MyBaseClass mock = Mock.Create<MyBaseClass>(BaseClass.WithConstructorParameters(1, 4, "bar"));

await That(mock.A).IsEqualTo(1);
await That(mock.B).IsEqualTo(4);
await That(mock.C).IsEqualTo("bar");
}

[Fact]
public async Task WithOptionalParameters_WithOneExplicitValue_ShouldUseExplicitAndDefaultValues()
{
MyBaseClass mock = Mock.Create<MyBaseClass>(BaseClass.WithConstructorParameters(1, 4));

await That(mock.A).IsEqualTo(1);
await That(mock.B).IsEqualTo(4);
await That(mock.C).IsEqualTo("foo");
}

public class MyBaseClass
{
public int A { get; }
public int B { get; }
public string C { get; }

public MyBaseClass(int a, int b = 2, string c = "foo")
{
A = a;
B = b;
C = c;
}
}
}
1 change: 1 addition & 0 deletions Tests/Mockolate.Tests/MatchExtensionsTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,7 @@ public async Task OutParameterMonitor_MultipleMonitors_ShouldAllMonitorValues()
mock.MyMethodWithOutParam(out _);
mock.MyMethodWithOutParam(out _);
mock.MyMethodWithOutParam(out _);
mock.MyMethodWithOptionalParameters(5);
Comment thread
vbreuss marked this conversation as resolved.

await That(monitor1.Values).IsEqualTo([1, 2, 3,]);
await That(monitor2.Values).IsEqualTo([1, 2, 3,]);
Expand Down
Loading
Loading