From f3268570ac3548b485a0aabe2ad7f5809f2833aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Valentin=20Breu=C3=9F?= Date: Sat, 28 Feb 2026 13:50:37 +0100 Subject: [PATCH 1/3] feat: allow verifying method setup calls --- .../Sources/Sources.MethodSetups.cs | 134 ++++++++++++------ Source/Mockolate/Mock.Verify.cs | 13 +- Source/Mockolate/MockExtensions.cs | 16 +++ Source/Mockolate/MockRegistration.Verify.cs | 27 +--- Source/Mockolate/Setup/IMethodMatch.cs | 14 ++ .../Mockolate/Setup/Interfaces.MethodSetup.cs | 27 +++- .../Mockolate/Setup/MethodParameterMatch.cs | 29 ++++ .../Mockolate/Setup/MethodParametersMatch.cs | 24 ++++ Source/Mockolate/Setup/MethodSetup.cs | 6 +- Source/Mockolate/Setup/ReturnMethodSetup.cs | 23 ++- Source/Mockolate/Setup/VoidMethodSetup.cs | 22 ++- .../Expected/Mockolate_net10.0.txt | 90 +++++++----- .../Expected/Mockolate_net8.0.txt | 90 +++++++----- .../Expected/Mockolate_netstandard2.0.txt | 90 +++++++----- .../MockMethods/InteractionsTests.cs | 13 +- .../MockMethods/SetupMethodTests.cs | 2 +- .../MockMethods/VerifyInvokedTests.cs | 16 +++ 17 files changed, 440 insertions(+), 196 deletions(-) create mode 100644 Source/Mockolate/Setup/IMethodMatch.cs create mode 100644 Source/Mockolate/Setup/MethodParameterMatch.cs create mode 100644 Source/Mockolate/Setup/MethodParametersMatch.cs diff --git a/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs b/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs index 95dce0c9..5df4caa6 100644 --- a/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs +++ b/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs @@ -110,7 +110,9 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete string parameters = string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(i => $"p{i}")); string discards = string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(_ => "_")); - sb.AppendXmlSummary($"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", "\t"); + sb.AppendXmlSummary( + $"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + "\t"); sb.Append("\tinternal interface IVoidMethodSetup<").Append(typeParams).Append(">").AppendLine(); sb.Append("\t{").AppendLine(); sb.AppendXmlSummary("Specifies if calling the base class implementation should be skipped."); @@ -150,32 +152,40 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete .AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary("Registers a that will calculate the exception to throw when the method is invoked."); + sb.AppendXmlSummary( + "Registers a that will calculate the exception to throw when the method is invoked."); sb.Append("\t\tIVoidMethodSetupReturnBuilder<").Append(typeParams).Append("> Throws(Func<") .Append(typeParams).Append(", Exception> callback);").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary("Registers a that will calculate the exception to throw when the method is invoked."); + sb.AppendXmlSummary( + "Registers a that will calculate the exception to throw when the method is invoked."); sb.Append("\t\tIVoidMethodSetupReturnBuilder<").Append(typeParams).Append("> Throws(Func callback);") .AppendLine(); sb.Append("}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary($"Sets up a callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", ""); + sb.AppendXmlSummary( + $"Sets up a callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + ""); sb.Append("internal interface IVoidMethodSetupCallbackBuilder<").Append(typeParams) .Append("> : IVoidMethodSetupCallbackWhenBuilder<").Append(typeParams).Append(">").AppendLine(); sb.Append("{").AppendLine(); sb.AppendXmlSummary("Runs the callback in parallel to the other callbacks."); sb.Append("\t\tIVoidMethodSetupCallbackBuilder<").Append(typeParams).Append("> InParallel();").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary("Limits the callback to only execute for method invocations where the predicate returns true."); - sb.AppendXmlRemarks("Provides a zero-based counter indicating how many times the method has been invoked so far."); + sb.AppendXmlSummary( + "Limits the callback to only execute for method invocations where the predicate returns true."); + sb.AppendXmlRemarks( + "Provides a zero-based counter indicating how many times the method has been invoked so far."); sb.Append("\t\tIVoidMethodSetupCallbackWhenBuilder<").Append(typeParams) .Append("> When(Func predicate);").AppendLine(); sb.Append("}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary($"Sets up a when callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", ""); + sb.AppendXmlSummary( + $"Sets up a when callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + ""); sb.Append("internal interface IVoidMethodSetupCallbackWhenBuilder<").Append(typeParams) .Append("> : IVoidMethodSetup<").Append(typeParams).Append(">").AppendLine(); sb.Append("{").AppendLine(); @@ -201,18 +211,24 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete sb.AppendLine(); - sb.AppendXmlSummary($"Sets up a return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", ""); + sb.AppendXmlSummary( + $"Sets up a return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + ""); sb.Append("internal interface IVoidMethodSetupReturnBuilder<").Append(typeParams) .Append("> : IVoidMethodSetupReturnWhenBuilder<").Append(typeParams).Append(">").AppendLine(); sb.Append("{").AppendLine(); - sb.AppendXmlSummary("Limits the throw to only execute for method invocations where the predicate returns true."); - sb.AppendXmlRemarks("Provides a zero-based counter indicating how many times the method has been invoked so far."); + sb.AppendXmlSummary( + "Limits the throw to only execute for method invocations where the predicate returns true."); + sb.AppendXmlRemarks( + "Provides a zero-based counter indicating how many times the method has been invoked so far."); sb.Append("\t\tIVoidMethodSetupReturnWhenBuilder<").Append(typeParams) .Append("> When(Func predicate);").AppendLine(); sb.Append("}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary($"Sets up a when return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", ""); + sb.AppendXmlSummary( + $"Sets up a when return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + ""); sb.Append("internal interface IVoidMethodSetupReturnWhenBuilder<").Append(typeParams) .Append("> : IVoidMethodSetup<").Append(typeParams).Append(">").AppendLine(); sb.Append("{").AppendLine(); @@ -236,7 +252,9 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete sb.Append("}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary($"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", ""); + sb.AppendXmlSummary( + $"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + ""); sb.Append("internal class VoidMethodSetup<").Append(typeParams) .Append("> : MethodSetup,").AppendLine(); sb.Append("\t\tIVoidMethodSetupCallbackBuilder<").Append(typeParams).Append(">,").AppendLine(); @@ -272,6 +290,9 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete } sb.Append(')').AppendLine(); + sb.Append("\t\t\t: base(new MethodParameterMatch(name, [") + .Append(string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(i => $"match{i}"))).Append("]))") + .AppendLine(); sb.Append("\t\t{").AppendLine(); sb.Append("\t\t\t_name = name;").AppendLine(); for (int i = 1; i <= numberOfParameters; i++) @@ -286,12 +307,13 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete .Append(string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(i => $"T{i}"))).Append("}\" />") .AppendLine(); sb.Append("\t\tpublic VoidMethodSetup(string name, IParameters matches)").AppendLine(); + sb.Append("\t\t\t: base(new MethodParametersMatch(name, matches))").AppendLine(); sb.Append("\t\t{").AppendLine(); sb.Append("\t\t\t_name = name;").AppendLine(); sb.Append("\t\t\t_matches = matches;").AppendLine(); sb.Append("\t\t}").AppendLine(); sb.AppendLine(); - + sb.AppendXmlSummary("Specifies if calling the base class implementation should be skipped."); sb.AppendXmlRemarks("If not specified, use ."); sb.Append("\t\tpublic IVoidMethodSetup<").Append(typeParams) @@ -381,7 +403,8 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete sb.Append("\t\t}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary("Registers a that will calculate the exception to throw when the method is invoked."); + sb.AppendXmlSummary( + "Registers a that will calculate the exception to throw when the method is invoked."); sb.Append("\t\tpublic IVoidMethodSetupReturnBuilder<").Append(typeParams).Append("> Throws(Func<") .Append(typeParams).Append(", Exception> callback)").AppendLine(); sb.Append("\t\t{").AppendLine(); @@ -393,7 +416,8 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete sb.Append("\t\t}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary("Registers a that will calculate the exception to throw when the method is invoked."); + sb.AppendXmlSummary( + "Registers a that will calculate the exception to throw when the method is invoked."); sb.Append("\t\tpublic IVoidMethodSetupReturnBuilder<").Append(typeParams) .Append("> Throws(Func callback)") .AppendLine(); @@ -629,7 +653,9 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame string parameters = string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(i => $"p{i}")); string discards = string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(_ => "_")); - sb.AppendXmlSummary($"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", "\t"); + sb.AppendXmlSummary( + $"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + "\t"); sb.Append("\tinternal interface IReturnMethodSetup") .AppendLine(); sb.Append("\t{").AppendLine(); @@ -683,18 +709,22 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame .AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary("Registers a that will calculate the exception to throw when the method is invoked."); + sb.AppendXmlSummary( + "Registers a that will calculate the exception to throw when the method is invoked."); sb.Append("\t\tIReturnMethodSetupReturnBuilder Throws(Func<") .Append(typeParams).Append(", Exception> callback);").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary("Registers a that will calculate the exception to throw when the method is invoked."); + sb.AppendXmlSummary( + "Registers a that will calculate the exception to throw when the method is invoked."); sb.Append("\t\tIReturnMethodSetupReturnBuilder Throws(Func callback);").AppendLine(); sb.Append("\t}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary($"Sets up a callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", "\t"); + sb.AppendXmlSummary( + $"Sets up a callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + "\t"); sb.Append("\tinternal interface IReturnMethodSetupCallbackBuilder : IReturnMethodSetupCallbackWhenBuilder") .AppendLine(); @@ -703,63 +733,79 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame sb.Append("\t\tIReturnMethodSetupCallbackBuilder InParallel();") .AppendLine(); sb.AppendLine(); - - sb.AppendXmlSummary("Limits the callback to only execute for method invocations where the predicate returns true."); - sb.AppendXmlRemarks("Provides a zero-based counter indicating how many times the method has been invoked so far."); + + sb.AppendXmlSummary( + "Limits the callback to only execute for method invocations where the predicate returns true."); + sb.AppendXmlRemarks( + "Provides a zero-based counter indicating how many times the method has been invoked so far."); sb.Append("\t\tIReturnMethodSetupCallbackWhenBuilder When(Func predicate);").AppendLine(); sb.Append("\t}").AppendLine(); sb.AppendLine(); - - sb.AppendXmlSummary($"Sets up a when callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", "\t"); + + sb.AppendXmlSummary( + $"Sets up a when callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + "\t"); sb.Append("\tinternal interface IReturnMethodSetupCallbackWhenBuilder : IReturnMethodSetup") .AppendLine(); sb.Append("\t{").AppendLine(); - + sb.AppendXmlSummary("Repeats the callback for the given number of ."); - sb.AppendXmlRemarks($"The number of times is only counted for actual executions ( evaluates to )."); + sb.AppendXmlRemarks( + $"The number of times is only counted for actual executions ( evaluates to )."); sb.Append("\t\tIReturnMethodSetupCallbackWhenBuilder For(int times);") .AppendLine(); sb.AppendLine(); - + sb.AppendXmlSummary("Deactivates the callback after the given number of ."); - sb.AppendXmlRemarks($"The number of times is only counted for actual executions ( evaluates to )."); + sb.AppendXmlRemarks( + $"The number of times is only counted for actual executions ( evaluates to )."); sb.Append("\t\tIReturnMethodSetup Only(int times);").AppendLine(); sb.Append("\t}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary($"Sets up a return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", "\t"); + sb.AppendXmlSummary( + $"Sets up a return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + "\t"); sb.Append("\tinternal interface IReturnMethodSetupReturnBuilder : IReturnMethodSetupReturnWhenBuilder") .AppendLine(); sb.Append("\t{").AppendLine(); - - sb.AppendXmlSummary("Limits the return/throw to only execute for method invocations where the predicate returns true."); - sb.AppendXmlRemarks("Provides a zero-based counter indicating how many times the method has been invoked so far."); + + sb.AppendXmlSummary( + "Limits the return/throw to only execute for method invocations where the predicate returns true."); + sb.AppendXmlRemarks( + "Provides a zero-based counter indicating how many times the method has been invoked so far."); sb.Append("\t\tIReturnMethodSetupReturnWhenBuilder When(Func predicate);").AppendLine(); sb.Append("\t}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary($"Sets up a when return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", "\t"); + sb.AppendXmlSummary( + $"Sets up a when return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + "\t"); sb.Append("\tinternal interface IReturnMethodSetupReturnWhenBuilder : IReturnMethodSetup") .AppendLine(); sb.Append("\t{").AppendLine(); - + sb.AppendXmlSummary("Repeats the callback for the given number of ."); - sb.AppendXmlRemarks($"The number of times is only counted for actual executions ( evaluates to )."); + sb.AppendXmlRemarks( + $"The number of times is only counted for actual executions ( evaluates to )."); sb.Append("\t\tIReturnMethodSetupReturnWhenBuilder For(int times);") .AppendLine(); sb.AppendLine(); sb.AppendXmlSummary("Deactivates the return/throw after the given number of ."); - sb.AppendXmlRemarks($"The number of times is only counted for actual executions ( evaluates to )."); + sb.AppendXmlRemarks( + $"The number of times is only counted for actual executions ( evaluates to )."); sb.Append("\t\tIReturnMethodSetup Only(int times);").AppendLine(); sb.Append("\t}").AppendLine(); sb.AppendLine(); - - sb.AppendXmlSummary($"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", "\t"); + + sb.AppendXmlSummary( + $"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", + "\t"); sb.Append("\tinternal class ReturnMethodSetup : MethodSetup,").AppendLine(); sb.Append("\t\tIReturnMethodSetupCallbackBuilder,").AppendLine(); @@ -795,6 +841,9 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame } sb.Append(')').AppendLine(); + sb.Append("\t\t\t: base(new MethodParameterMatch(name, [") + .Append(string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(i => $"match{i}"))).Append("]))") + .AppendLine(); sb.Append("\t\t{").AppendLine(); sb.Append("\t\t\t_name = name;").AppendLine(); for (int i = 1; i <= numberOfParameters; i++) @@ -809,6 +858,7 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame .Append(string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(i => $"T{i}"))).Append("}\" />") .AppendLine(); sb.Append("\t\tpublic ReturnMethodSetup(string name, IParameters matches)").AppendLine(); + sb.Append("\t\t\t: base(new MethodParametersMatch(name, matches))").AppendLine(); sb.Append("\t\t{").AppendLine(); sb.Append("\t\t\t_name = name;").AppendLine(); sb.Append("\t\t\t_matches = matches;").AppendLine(); @@ -933,8 +983,9 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame sb.Append("\t\t\treturn this;").AppendLine(); sb.Append("\t\t}").AppendLine(); sb.AppendLine(); - - sb.AppendXmlSummary("Registers a that will calculate the exception to throw when the method is invoked."); + + sb.AppendXmlSummary( + "Registers a that will calculate the exception to throw when the method is invoked."); sb.Append("\t\tpublic IReturnMethodSetupReturnBuilder Throws(Func<") .Append(typeParams).Append(", Exception> callback)").AppendLine(); sb.Append("\t\t{").AppendLine(); @@ -948,7 +999,8 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame sb.Append("\t\t}").AppendLine(); sb.AppendLine(); - sb.AppendXmlSummary("Registers a that will calculate the exception to throw when the method is invoked."); + sb.AppendXmlSummary( + "Registers a that will calculate the exception to throw when the method is invoked."); sb.Append("\t\tpublic IReturnMethodSetupReturnBuilder Throws(Func callback)") .AppendLine(); diff --git a/Source/Mockolate/Mock.Verify.cs b/Source/Mockolate/Mock.Verify.cs index 4c085d9c..45182a7b 100644 --- a/Source/Mockolate/Mock.Verify.cs +++ b/Source/Mockolate/Mock.Verify.cs @@ -1,4 +1,5 @@ using Mockolate.Parameters; +using Mockolate.Setup; using Mockolate.Verify; namespace Mockolate; @@ -24,28 +25,28 @@ bool IMockVerify.ThatAllSetupsAreUsed() /// VerificationResult IMockVerifyInvokedWithToString.ToString() - => Registrations.Method(Subject, Registrations.Prefix + ".ToString"); + => Registrations.Method(Subject, new MethodParameterMatch(Registrations.Prefix + ".ToString", [])); /// VerificationResult IMockVerifyInvokedWithEquals.Equals(IParameter? obj) - => Registrations.Method(Subject, Registrations.Prefix + ".Equals", - new NamedParameter("obj", (IParameter)(obj ?? It.IsNull()))); + => Registrations.Method(Subject, new MethodParameterMatch(Registrations.Prefix + ".Equals", + [new NamedParameter("obj", (IParameter)(obj ?? It.IsNull())),])); /// VerificationResult IMockVerifyInvokedWithGetHashCode.GetHashCode() - => Registrations.Method(Subject, Registrations.Prefix + ".GetHashCode"); + => Registrations.Method(Subject, new MethodParameterMatch(Registrations.Prefix + ".GetHashCode", [])); /// /// Counts the invocations of method with matching . /// public VerificationResult Method(string methodName, params NamedParameter[] parameters) - => Registrations.Method(Subject, methodName, parameters); + => Registrations.Method(Subject, new MethodParameterMatch(methodName, parameters)); /// /// Counts the invocations of method with matching . /// public VerificationResult Method(string methodName, IParameters parameters) - => Registrations.Method(Subject, methodName, parameters); + => Registrations.Method(Subject, new MethodParametersMatch(methodName, parameters)); /// /// Counts the getter accesses of property . diff --git a/Source/Mockolate/MockExtensions.cs b/Source/Mockolate/MockExtensions.cs index 6a8f9c79..f7b4dacd 100644 --- a/Source/Mockolate/MockExtensions.cs +++ b/Source/Mockolate/MockExtensions.cs @@ -1,4 +1,6 @@ +using Mockolate.Exceptions; using Mockolate.Setup; +using Mockolate.Verify; namespace Mockolate; @@ -18,4 +20,18 @@ public static void ClearAllInteractions(this IMockSetup mock) hasMockRegistration.Registrations.ClearAllInteractions(); } } + + /// + /// Verifies the method invocations for the on the mock. + /// + public static VerificationResult InvokedSetup(this IMockVerify verify, IMethodSetup setup) + { + if (setup is IVerifiableMethodSetup verifiableMethodSetup && + verify is Mock mock) + { + return mock.Registrations.Method(mock.Subject, verifiableMethodSetup.GetMatch()); + } + + throw new MockException("The subject is no mock."); + } } diff --git a/Source/Mockolate/MockRegistration.Verify.cs b/Source/Mockolate/MockRegistration.Verify.cs index 264b1d34..f5e9dce7 100644 --- a/Source/Mockolate/MockRegistration.Verify.cs +++ b/Source/Mockolate/MockRegistration.Verify.cs @@ -12,37 +12,18 @@ namespace Mockolate; public partial class MockRegistration { /// - /// Counts the invocations of method with matching on the - /// . + /// Counts the invocations of methods matching the on the . /// - public VerificationResult Method(T subject, string methodName, params NamedParameter[] parameters) + public VerificationResult Method(T subject, IMethodMatch methodMatch) => new( subject, Interactions, Interactions.Interactions .OfType() - .Where(method => method.Name.Equals(methodName) && - method.Parameters.Length == parameters.Length && - !parameters - .Where((parameter, i) => !parameter.Matches(method.Parameters[i])) - .Any()) + .Where(methodMatch.Matches) .Cast() .ToArray(), - $"invoked method {methodName.SubstringAfterLast('.')}({string.Join(", ", parameters.Select(x => x.Parameter.ToString()))})"); - - /// - /// Counts the invocations of method with matching on the - /// . - /// - public VerificationResult Method(T subject, string methodName, IParameters parameters) => new(subject, - Interactions, - Interactions.Interactions - .OfType() - .Where(method => method.Name.Equals(methodName) && - parameters.Matches(method.Parameters)) - .Cast() - .ToArray(), - $"invoked method {methodName.SubstringAfterLast('.')}({parameters})"); + $"invoked method {methodMatch}"); /// /// Counts the getter accesses of property on the . diff --git a/Source/Mockolate/Setup/IMethodMatch.cs b/Source/Mockolate/Setup/IMethodMatch.cs new file mode 100644 index 00000000..c4931746 --- /dev/null +++ b/Source/Mockolate/Setup/IMethodMatch.cs @@ -0,0 +1,14 @@ +using Mockolate.Interactions; + +namespace Mockolate.Setup; + +/// +/// A method match to verify method invocations from a setup. +/// +public interface IMethodMatch +{ + /// + /// Checks if the matches. + /// + bool Matches(MethodInvocation methodInvocation); +} diff --git a/Source/Mockolate/Setup/Interfaces.MethodSetup.cs b/Source/Mockolate/Setup/Interfaces.MethodSetup.cs index 8a2c6aba..92abb66a 100644 --- a/Source/Mockolate/Setup/Interfaces.MethodSetup.cs +++ b/Source/Mockolate/Setup/Interfaces.MethodSetup.cs @@ -3,6 +3,23 @@ namespace Mockolate.Setup; +/// +/// Marker interface for method setups. +/// +public interface IMethodSetup; + +/// +/// Interface for verifiable method setup. It hides the implementation details to get the underlying +/// . +/// +public interface IVerifiableMethodSetup +{ + /// + /// Gets the used to match against method invocations. + /// + IMethodMatch GetMatch(); +} + /// /// Interface for hiding some implementation details of . /// @@ -63,7 +80,7 @@ TResult Invoke(MethodInvocation methodInvocation, MockBehavior behavior /// /// Sets up a method returning . /// -public interface IReturnMethodSetup +public interface IReturnMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. @@ -209,7 +226,7 @@ public interface IReturnMethodSetupReturnWhenBuilder /// /// Sets up a method returning . /// -public interface IReturnMethodSetup +public interface IReturnMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. @@ -370,7 +387,7 @@ public interface IReturnMethodSetupReturnWhenBuilder /// /// Sets up a method returning . /// -public interface IReturnMethodSetup +public interface IReturnMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. @@ -531,7 +548,7 @@ public interface IReturnMethodSetupReturnWhenBuilder /// /// Sets up a method returning . /// -public interface IReturnMethodSetup +public interface IReturnMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. @@ -693,7 +710,7 @@ public interface IReturnMethodSetupReturnWhenBuilder /// Sets up a method returning . /// -public interface IReturnMethodSetup +public interface IReturnMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. diff --git a/Source/Mockolate/Setup/MethodParameterMatch.cs b/Source/Mockolate/Setup/MethodParameterMatch.cs new file mode 100644 index 00000000..896e14ca --- /dev/null +++ b/Source/Mockolate/Setup/MethodParameterMatch.cs @@ -0,0 +1,29 @@ +using System.Linq; +using Mockolate.Interactions; +using Mockolate.Internals; +using Mockolate.Parameters; + +namespace Mockolate.Setup; + +/// +/// Matches a method by name and parameters. +/// +/// +/// During verification, the is compared to the method name of the method invocation, +/// and the are matched one by one against the corresponding parameter in the method +/// invocation. +/// +public readonly struct MethodParameterMatch(string methodName, NamedParameter[] parameters) : IMethodMatch +{ + /// + public bool Matches(MethodInvocation method) + => method.Name.Equals(methodName) && + method.Parameters.Length == parameters.Length && + !parameters + .Where((parameter, i) => !parameter.Matches(method.Parameters[i])) + .Any(); + + /// + public override string ToString() + => $"{methodName.SubstringAfterLast('.')}({string.Join(", ", parameters.Select(x => x.Parameter.ToString()))})"; +} diff --git a/Source/Mockolate/Setup/MethodParametersMatch.cs b/Source/Mockolate/Setup/MethodParametersMatch.cs new file mode 100644 index 00000000..3bb1055c --- /dev/null +++ b/Source/Mockolate/Setup/MethodParametersMatch.cs @@ -0,0 +1,24 @@ +using Mockolate.Interactions; +using Mockolate.Internals; +using Mockolate.Parameters; + +namespace Mockolate.Setup; + +/// +/// Matches a method by name and parameters. +/// +/// +/// During verification, the is compared to the method name of the method invocation, +/// and the are matched against the parameters in the method invocation. +/// +public readonly struct MethodParametersMatch(string methodName, IParameters parameters) : IMethodMatch +{ + /// + public bool Matches(MethodInvocation method) + => method.Name.Equals(methodName) && + parameters.Matches(method.Parameters); + + /// + public override string ToString() + => $"{methodName.SubstringAfterLast('.')}({parameters})"; +} diff --git a/Source/Mockolate/Setup/MethodSetup.cs b/Source/Mockolate/Setup/MethodSetup.cs index fdd01523..414b7c49 100644 --- a/Source/Mockolate/Setup/MethodSetup.cs +++ b/Source/Mockolate/Setup/MethodSetup.cs @@ -9,7 +9,7 @@ namespace Mockolate.Setup; /// /// Base class for method setups. /// -public abstract class MethodSetup : IInteractiveMethodSetup +public abstract class MethodSetup(IMethodMatch methodMatch) : IInteractiveMethodSetup, IVerifiableMethodSetup { /// bool IInteractiveMethodSetup.HasReturnCalls() @@ -48,6 +48,10 @@ void IInteractiveMethodSetup.Invoke(MethodInvocation methodInvocation, MockBehav public void TriggerCallbacks(object?[] parameters) => TriggerParameterCallbacks(parameters); + /// + public IMethodMatch GetMatch() + => methodMatch; + /// /// Gets the flag indicating if the base class implementation should be skipped. /// diff --git a/Source/Mockolate/Setup/ReturnMethodSetup.cs b/Source/Mockolate/Setup/ReturnMethodSetup.cs index 0668f668..fbbef2a3 100644 --- a/Source/Mockolate/Setup/ReturnMethodSetup.cs +++ b/Source/Mockolate/Setup/ReturnMethodSetup.cs @@ -9,16 +9,17 @@ namespace Mockolate.Setup; /// /// Sets up a method returning . /// -public class ReturnMethodSetup(string name) : MethodSetup, - IReturnMethodSetupCallbackBuilder, IReturnMethodSetupReturnBuilder +public class ReturnMethodSetup(string name) + : MethodSetup(new MethodParameterMatch(name, [])), + IReturnMethodSetupCallbackBuilder, IReturnMethodSetupReturnBuilder { private readonly List>> _callbacks = []; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public IReturnMethodSetup SkippingBaseClass(bool skipBaseClass = true) @@ -226,14 +227,15 @@ public class ReturnMethodSetup : MethodSetup, private readonly IParameters? _matches; private readonly string _name; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public ReturnMethodSetup(string name, NamedParameter match1) + : base(new MethodParameterMatch(name, [match1,])) { _name = name; _match1 = match1; @@ -241,6 +243,7 @@ public ReturnMethodSetup(string name, NamedParameter match1) /// public ReturnMethodSetup(string name, IParameters matches) + : base(new MethodParametersMatch(name, matches)) { _name = name; _matches = matches; @@ -506,14 +509,15 @@ public class ReturnMethodSetup : MethodSetup, private readonly IParameters? _matches; private readonly string _name; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public ReturnMethodSetup(string name, NamedParameter match1, NamedParameter match2) + : base(new MethodParameterMatch(name, [match1, match2,])) { _name = name; _match1 = match1; @@ -522,6 +526,7 @@ public ReturnMethodSetup(string name, NamedParameter match1, NamedParameter matc /// public ReturnMethodSetup(string name, IParameters matches) + : base(new MethodParametersMatch(name, matches)) { _name = name; _matches = matches; @@ -797,11 +802,11 @@ public class ReturnMethodSetup : MethodSetup, private readonly IParameters? _matches; private readonly string _name; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public ReturnMethodSetup( @@ -809,6 +814,7 @@ public ReturnMethodSetup( NamedParameter match1, NamedParameter match2, NamedParameter match3) + : base(new MethodParameterMatch(name, [match1, match2, match3,])) { _name = name; _match1 = match1; @@ -818,6 +824,7 @@ public ReturnMethodSetup( /// public ReturnMethodSetup(string name, IParameters matches) + : base(new MethodParametersMatch(name, matches)) { _name = name; _matches = matches; @@ -1104,11 +1111,11 @@ public class ReturnMethodSetup : MethodSetup, private readonly IParameters? _matches; private readonly string _name; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public ReturnMethodSetup( @@ -1117,6 +1124,7 @@ public ReturnMethodSetup( NamedParameter match2, NamedParameter match3, NamedParameter match4) + : base(new MethodParameterMatch(name, [match1, match2, match3, match4,])) { _name = name; _match1 = match1; @@ -1127,6 +1135,7 @@ public ReturnMethodSetup( /// public ReturnMethodSetup(string name, IParameters matches) + : base(new MethodParametersMatch(name, matches)) { _name = name; _matches = matches; diff --git a/Source/Mockolate/Setup/VoidMethodSetup.cs b/Source/Mockolate/Setup/VoidMethodSetup.cs index 2ebaddb7..34a73e14 100644 --- a/Source/Mockolate/Setup/VoidMethodSetup.cs +++ b/Source/Mockolate/Setup/VoidMethodSetup.cs @@ -9,15 +9,17 @@ namespace Mockolate.Setup; /// /// Sets up a method returning . /// -public class VoidMethodSetup(string name) : MethodSetup, IVoidMethodSetupCallbackBuilder, IVoidMethodSetupReturnBuilder +public class VoidMethodSetup(string name) + : MethodSetup(new MethodParameterMatch(name, [])), + IVoidMethodSetupCallbackBuilder, IVoidMethodSetupReturnBuilder { private readonly List>> _callbacks = []; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) @@ -202,14 +204,15 @@ public class VoidMethodSetup : MethodSetup, private readonly IParameters? _matches; private readonly string _name; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public VoidMethodSetup(string name, NamedParameter match1) + : base(new MethodParameterMatch(name, [match1,])) { _name = name; _match1 = match1; @@ -217,6 +220,7 @@ public VoidMethodSetup(string name, NamedParameter match1) /// public VoidMethodSetup(string name, IParameters matches) + : base(new MethodParametersMatch(name, matches)) { _name = name; _matches = matches; @@ -444,14 +448,15 @@ public class VoidMethodSetup : MethodSetup, private readonly IParameters? _matches; private readonly string _name; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public VoidMethodSetup(string name, NamedParameter match1, NamedParameter match2) + : base(new MethodParameterMatch(name, [match1, match2,])) { _name = name; _match1 = match1; @@ -460,6 +465,7 @@ public VoidMethodSetup(string name, NamedParameter match1, NamedParameter match2 /// public VoidMethodSetup(string name, IParameters matches) + : base(new MethodParametersMatch(name, matches)) { _name = name; _matches = matches; @@ -689,11 +695,11 @@ public class VoidMethodSetup : MethodSetup, private readonly IParameters? _matches; private readonly string _name; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public VoidMethodSetup( @@ -701,6 +707,7 @@ public VoidMethodSetup( NamedParameter match1, NamedParameter match2, NamedParameter match3) + : base(new MethodParameterMatch(name, [match1, match2, match3,])) { _name = name; _match1 = match1; @@ -710,6 +717,7 @@ public VoidMethodSetup( /// public VoidMethodSetup(string name, IParameters matches) + : base(new MethodParametersMatch(name, matches)) { _name = name; _matches = matches; @@ -943,11 +951,11 @@ public class VoidMethodSetup : MethodSetup, private readonly IParameters? _matches; private readonly string _name; private readonly List>> _returnCallbacks = []; - private bool? _skipBaseClass; private Callback? _currentCallback; private int _currentCallbacksIndex; private Callback? _currentReturnCallback; private int _currentReturnCallbackIndex; + private bool? _skipBaseClass; /// public VoidMethodSetup( @@ -956,6 +964,7 @@ public VoidMethodSetup( NamedParameter match2, NamedParameter match3, NamedParameter match4) + : base(new MethodParameterMatch(name, [match1, match2, match3, match4,])) { _name = name; _match1 = match1; @@ -966,6 +975,7 @@ public VoidMethodSetup( /// public VoidMethodSetup(string name, IParameters matches) + : base(new MethodParametersMatch(name, matches)) { _name = name; _matches = matches; diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt index a7140d37..19ad3c68 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt @@ -113,6 +113,7 @@ namespace Mockolate { public static void ClearAllInteractions(this Mockolate.Setup.IMockSetup mock) where T : class { } + public static Mockolate.Verify.VerificationResult InvokedSetup(this Mockolate.Verify.IMockVerify verify, Mockolate.Setup.IMethodSetup setup) { } } [System.Diagnostics.DebuggerDisplay("{ToString()}")] public class MockRegistration @@ -131,8 +132,7 @@ namespace Mockolate public Mockolate.Verify.VerificationResult Indexer(T subject, Mockolate.Parameters.IParameter? value, params Mockolate.Parameters.NamedParameter[] parameters) { } public Mockolate.Setup.MethodSetupResult InvokeMethod(string methodName, params Mockolate.Parameters.NamedParameterValue[] parameters) { } public Mockolate.Setup.MethodSetupResult InvokeMethod(string methodName, System.Func defaultValue, params Mockolate.Parameters.NamedParameterValue[] parameters) { } - public Mockolate.Verify.VerificationResult Method(T subject, string methodName, Mockolate.Parameters.IParameters parameters) { } - public Mockolate.Verify.VerificationResult Method(T subject, string methodName, params Mockolate.Parameters.NamedParameter[] parameters) { } + public Mockolate.Verify.VerificationResult Method(T subject, Mockolate.Setup.IMethodMatch methodMatch) { } public Mockolate.Verify.VerificationResult Property(T subject, string propertyName) { } public Mockolate.Verify.VerificationResult Property(T subject, string propertyName, Mockolate.Parameters.IParameter value) { } public void Raise(string eventName, params object?[] parameters) { } @@ -880,6 +880,11 @@ namespace Mockolate.Setup bool Matches(Mockolate.Interactions.PropertyAccess propertyAccess); bool? SkipBaseClass(); } + public interface IMethodMatch + { + bool Matches(Mockolate.Interactions.MethodInvocation methodInvocation); + } + public interface IMethodSetup { } public interface IMockMethodSetupWithEqualsWithGetHashCode : Mockolate.IInteractiveMock, Mockolate.Setup.IMockMethodSetupWithEquals, Mockolate.Setup.IMockMethodSetupWithGetHashCode, Mockolate.Setup.IMockMethodSetup { } public interface IMockMethodSetupWithEquals : Mockolate.IInteractiveMock, Mockolate.Setup.IMockMethodSetup { @@ -952,102 +957,102 @@ namespace Mockolate.Setup public interface IProtectedMockMethodSetup : Mockolate.IInteractiveMock { } public interface IProtectedMockPropertySetup : Mockolate.IInteractiveMock { } public interface IProtectedMockSetup : Mockolate.IInteractiveMock { } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1059,7 +1064,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1074,7 +1079,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1089,7 +1094,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1104,7 +1109,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1120,6 +1125,10 @@ namespace Mockolate.Setup where TException : System.Exception, new (); } public interface ISetup { } + public interface IVerifiableMethodSetup + { + Mockolate.Setup.IMethodMatch GetMatch(); + } public interface IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1396,10 +1405,23 @@ namespace Mockolate.Setup public Mockolate.Setup.IIndexerSetupReturnBuilder Throws() where TException : System.Exception, new () { } } - public abstract class MethodSetup : Mockolate.Setup.IInteractiveMethodSetup, Mockolate.Setup.ISetup + public readonly struct MethodParameterMatch : Mockolate.Setup.IMethodMatch + { + public MethodParameterMatch(string methodName, Mockolate.Parameters.NamedParameter[] parameters) { } + public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public override string ToString() { } + } + public readonly struct MethodParametersMatch : Mockolate.Setup.IMethodMatch + { + public MethodParametersMatch(string methodName, Mockolate.Parameters.IParameters parameters) { } + public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public override string ToString() { } + } + public abstract class MethodSetup : Mockolate.Setup.IInteractiveMethodSetup, Mockolate.Setup.ISetup, Mockolate.Setup.IVerifiableMethodSetup { - protected MethodSetup() { } + protected MethodSetup(Mockolate.Setup.IMethodMatch methodMatch) { } protected abstract void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior); + public Mockolate.Setup.IMethodMatch GetMatch() { } protected abstract TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator); protected abstract bool? GetSkipBaseClass(); protected virtual bool HasReturnCalls() { } @@ -1470,7 +1492,7 @@ namespace Mockolate.Setup public static System.ReadOnlySpan op_Implicit(Mockolate.Setup.ReadOnlySpanWrapper wrapper) { } public static Mockolate.Setup.ReadOnlySpanWrapper op_Implicit(System.ReadOnlySpan span) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name) { } public Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback) { } @@ -1492,7 +1514,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { } @@ -1518,7 +1540,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { } @@ -1544,7 +1566,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { } @@ -1570,7 +1592,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3, Mockolate.Parameters.NamedParameter match4) { } diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt index 864ccb26..6e68bbd4 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt @@ -112,6 +112,7 @@ namespace Mockolate { public static void ClearAllInteractions(this Mockolate.Setup.IMockSetup mock) where T : class { } + public static Mockolate.Verify.VerificationResult InvokedSetup(this Mockolate.Verify.IMockVerify verify, Mockolate.Setup.IMethodSetup setup) { } } [System.Diagnostics.DebuggerDisplay("{ToString()}")] public class MockRegistration @@ -130,8 +131,7 @@ namespace Mockolate public Mockolate.Verify.VerificationResult Indexer(T subject, Mockolate.Parameters.IParameter? value, params Mockolate.Parameters.NamedParameter[] parameters) { } public Mockolate.Setup.MethodSetupResult InvokeMethod(string methodName, params Mockolate.Parameters.NamedParameterValue[] parameters) { } public Mockolate.Setup.MethodSetupResult InvokeMethod(string methodName, System.Func defaultValue, params Mockolate.Parameters.NamedParameterValue[] parameters) { } - public Mockolate.Verify.VerificationResult Method(T subject, string methodName, Mockolate.Parameters.IParameters parameters) { } - public Mockolate.Verify.VerificationResult Method(T subject, string methodName, params Mockolate.Parameters.NamedParameter[] parameters) { } + public Mockolate.Verify.VerificationResult Method(T subject, Mockolate.Setup.IMethodMatch methodMatch) { } public Mockolate.Verify.VerificationResult Property(T subject, string propertyName) { } public Mockolate.Verify.VerificationResult Property(T subject, string propertyName, Mockolate.Parameters.IParameter value) { } public void Raise(string eventName, params object?[] parameters) { } @@ -879,6 +879,11 @@ namespace Mockolate.Setup bool Matches(Mockolate.Interactions.PropertyAccess propertyAccess); bool? SkipBaseClass(); } + public interface IMethodMatch + { + bool Matches(Mockolate.Interactions.MethodInvocation methodInvocation); + } + public interface IMethodSetup { } public interface IMockMethodSetupWithEqualsWithGetHashCode : Mockolate.IInteractiveMock, Mockolate.Setup.IMockMethodSetupWithEquals, Mockolate.Setup.IMockMethodSetupWithGetHashCode, Mockolate.Setup.IMockMethodSetup { } public interface IMockMethodSetupWithEquals : Mockolate.IInteractiveMock, Mockolate.Setup.IMockMethodSetup { @@ -951,102 +956,102 @@ namespace Mockolate.Setup public interface IProtectedMockMethodSetup : Mockolate.IInteractiveMock { } public interface IProtectedMockPropertySetup : Mockolate.IInteractiveMock { } public interface IProtectedMockSetup : Mockolate.IInteractiveMock { } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1058,7 +1063,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1073,7 +1078,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1088,7 +1093,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1103,7 +1108,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1119,6 +1124,10 @@ namespace Mockolate.Setup where TException : System.Exception, new (); } public interface ISetup { } + public interface IVerifiableMethodSetup + { + Mockolate.Setup.IMethodMatch GetMatch(); + } public interface IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1395,10 +1404,23 @@ namespace Mockolate.Setup public Mockolate.Setup.IIndexerSetupReturnBuilder Throws() where TException : System.Exception, new () { } } - public abstract class MethodSetup : Mockolate.Setup.IInteractiveMethodSetup, Mockolate.Setup.ISetup + public readonly struct MethodParameterMatch : Mockolate.Setup.IMethodMatch + { + public MethodParameterMatch(string methodName, Mockolate.Parameters.NamedParameter[] parameters) { } + public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public override string ToString() { } + } + public readonly struct MethodParametersMatch : Mockolate.Setup.IMethodMatch + { + public MethodParametersMatch(string methodName, Mockolate.Parameters.IParameters parameters) { } + public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public override string ToString() { } + } + public abstract class MethodSetup : Mockolate.Setup.IInteractiveMethodSetup, Mockolate.Setup.ISetup, Mockolate.Setup.IVerifiableMethodSetup { - protected MethodSetup() { } + protected MethodSetup(Mockolate.Setup.IMethodMatch methodMatch) { } protected abstract void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior); + public Mockolate.Setup.IMethodMatch GetMatch() { } protected abstract TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator); protected abstract bool? GetSkipBaseClass(); protected virtual bool HasReturnCalls() { } @@ -1469,7 +1491,7 @@ namespace Mockolate.Setup public static System.ReadOnlySpan op_Implicit(Mockolate.Setup.ReadOnlySpanWrapper wrapper) { } public static Mockolate.Setup.ReadOnlySpanWrapper op_Implicit(System.ReadOnlySpan span) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name) { } public Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback) { } @@ -1491,7 +1513,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { } @@ -1517,7 +1539,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { } @@ -1543,7 +1565,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { } @@ -1569,7 +1591,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3, Mockolate.Parameters.NamedParameter match4) { } diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt index f946ed4f..14dc3d8a 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt @@ -107,6 +107,7 @@ namespace Mockolate { public static void ClearAllInteractions(this Mockolate.Setup.IMockSetup mock) where T : class { } + public static Mockolate.Verify.VerificationResult InvokedSetup(this Mockolate.Verify.IMockVerify verify, Mockolate.Setup.IMethodSetup setup) { } } [System.Diagnostics.DebuggerDisplay("{ToString()}")] public class MockRegistration @@ -125,8 +126,7 @@ namespace Mockolate public Mockolate.Verify.VerificationResult Indexer(T subject, Mockolate.Parameters.IParameter? value, params Mockolate.Parameters.NamedParameter[] parameters) { } public Mockolate.Setup.MethodSetupResult InvokeMethod(string methodName, params Mockolate.Parameters.NamedParameterValue[] parameters) { } public Mockolate.Setup.MethodSetupResult InvokeMethod(string methodName, System.Func defaultValue, params Mockolate.Parameters.NamedParameterValue[] parameters) { } - public Mockolate.Verify.VerificationResult Method(T subject, string methodName, Mockolate.Parameters.IParameters parameters) { } - public Mockolate.Verify.VerificationResult Method(T subject, string methodName, params Mockolate.Parameters.NamedParameter[] parameters) { } + public Mockolate.Verify.VerificationResult Method(T subject, Mockolate.Setup.IMethodMatch methodMatch) { } public Mockolate.Verify.VerificationResult Property(T subject, string propertyName) { } public Mockolate.Verify.VerificationResult Property(T subject, string propertyName, Mockolate.Parameters.IParameter value) { } public void Raise(string eventName, params object?[] parameters) { } @@ -842,6 +842,11 @@ namespace Mockolate.Setup bool Matches(Mockolate.Interactions.PropertyAccess propertyAccess); bool? SkipBaseClass(); } + public interface IMethodMatch + { + bool Matches(Mockolate.Interactions.MethodInvocation methodInvocation); + } + public interface IMethodSetup { } public interface IMockMethodSetupWithEqualsWithGetHashCode : Mockolate.IInteractiveMock, Mockolate.Setup.IMockMethodSetupWithEquals, Mockolate.Setup.IMockMethodSetupWithGetHashCode, Mockolate.Setup.IMockMethodSetup { } public interface IMockMethodSetupWithEquals : Mockolate.IInteractiveMock, Mockolate.Setup.IMockMethodSetup { @@ -914,102 +919,102 @@ namespace Mockolate.Setup public interface IProtectedMockMethodSetup : Mockolate.IInteractiveMock { } public interface IProtectedMockPropertySetup : Mockolate.IInteractiveMock { } public interface IProtectedMockSetup : Mockolate.IInteractiveMock { } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IReturnMethodSetup + public interface IReturnMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup { Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IReturnMethodSetup Only(int times); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1021,7 +1026,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1036,7 +1041,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1051,7 +1056,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1066,7 +1071,7 @@ namespace Mockolate.Setup Mockolate.Setup.IReturnMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IReturnMethodSetup + public interface IReturnMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback); @@ -1082,6 +1087,10 @@ namespace Mockolate.Setup where TException : System.Exception, new (); } public interface ISetup { } + public interface IVerifiableMethodSetup + { + Mockolate.Setup.IMethodMatch GetMatch(); + } public interface IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1358,10 +1367,23 @@ namespace Mockolate.Setup public Mockolate.Setup.IIndexerSetupReturnBuilder Throws() where TException : System.Exception, new () { } } - public abstract class MethodSetup : Mockolate.Setup.IInteractiveMethodSetup, Mockolate.Setup.ISetup + public readonly struct MethodParameterMatch : Mockolate.Setup.IMethodMatch + { + public MethodParameterMatch(string methodName, Mockolate.Parameters.NamedParameter[] parameters) { } + public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public override string ToString() { } + } + public readonly struct MethodParametersMatch : Mockolate.Setup.IMethodMatch + { + public MethodParametersMatch(string methodName, Mockolate.Parameters.IParameters parameters) { } + public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public override string ToString() { } + } + public abstract class MethodSetup : Mockolate.Setup.IInteractiveMethodSetup, Mockolate.Setup.ISetup, Mockolate.Setup.IVerifiableMethodSetup { - protected MethodSetup() { } + protected MethodSetup(Mockolate.Setup.IMethodMatch methodMatch) { } protected abstract void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior); + public Mockolate.Setup.IMethodMatch GetMatch() { } protected abstract TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator); protected abstract bool? GetSkipBaseClass(); protected virtual bool HasReturnCalls() { } @@ -1425,7 +1447,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name) { } public Mockolate.Setup.IReturnMethodSetupCallbackBuilder Do(System.Action callback) { } @@ -1447,7 +1469,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { } @@ -1473,7 +1495,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { } @@ -1499,7 +1521,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { } @@ -1525,7 +1547,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup + public class ReturnMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder, Mockolate.Setup.IReturnMethodSetupReturnBuilder, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder, Mockolate.Setup.IReturnMethodSetup { public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3, Mockolate.Parameters.NamedParameter match4) { } diff --git a/Tests/Mockolate.Tests/MockMethods/InteractionsTests.cs b/Tests/Mockolate.Tests/MockMethods/InteractionsTests.cs index 23c980de..838152c2 100644 --- a/Tests/Mockolate.Tests/MockMethods/InteractionsTests.cs +++ b/Tests/Mockolate.Tests/MockMethods/InteractionsTests.cs @@ -1,5 +1,6 @@ using Mockolate.Interactions; using Mockolate.Parameters; +using Mockolate.Setup; using Mockolate.Tests.TestHelpers; using Mockolate.Verify; @@ -15,7 +16,8 @@ public async Task Method_WhenNameAndValueMatches_ShouldReturnOnce() registration.InvokeMethod("foo.bar", new NamedParameterValue("p1", 4)); VerificationResult result = - registration.Method(mock, "foo.bar", new NamedParameter("p1", (IParameter)It.IsAny())); + registration.Method(mock, + new MethodParameterMatch("foo.bar", [new NamedParameter("p1", (IParameter)It.IsAny()),])); await That(result).Once(); } @@ -28,7 +30,8 @@ public async Task Method_WhenOnlyNameMatches_ShouldReturnNever() registration.InvokeMethod("foo.bar", new NamedParameterValue("p1", 4)); VerificationResult result = - registration.Method(mock, "foo.bar", new NamedParameter("p1", (IParameter)It.IsAny())); + registration.Method(mock, + new MethodParameterMatch("foo.bar", [new NamedParameter("p1", (IParameter)It.IsAny()),])); await That(result).Never(); } @@ -41,7 +44,8 @@ public async Task Method_WhenOnlyValueMatches_ShouldReturnNever() registration.InvokeMethod("foo.bar", new NamedParameterValue("p1", 4)); VerificationResult result = - registration.Method(mock, "baz.bar", new NamedParameter("p1", (IParameter)It.IsAny())); + registration.Method(mock, + new MethodParameterMatch("baz.bar", [new NamedParameter("p1", (IParameter)It.IsAny()),])); await That(result).Never(); } @@ -53,7 +57,8 @@ public async Task Method_WithoutInteractions_ShouldReturnNeverResult() MockRegistration registration = ((IHasMockRegistration)mock).Registrations; VerificationResult result = - registration.Method(mock, "foo.bar", new NamedParameter("p1", (IParameter)It.IsAny())); + registration.Method(mock, + new MethodParameterMatch("foo.bar", [new NamedParameter("p1", (IParameter)It.IsAny()),])); await That(result).Never(); await That(((IVerificationResult)result).Expectation).IsEqualTo("invoked method bar(It.IsAny())"); diff --git a/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs b/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs index d82dfc26..2be7a605 100644 --- a/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs +++ b/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs @@ -1140,7 +1140,7 @@ await That(result) } } - public class MyMethodSetup : MethodSetup + public class MyMethodSetup() : MethodSetup(new MethodParameterMatch("", [])) { public static void DoTriggerCallbacks(NamedParameter?[] namedParameters, object?[] values) => TriggerCallbacks(namedParameters, values); diff --git a/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs b/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs index 864cd50f..fcbebe78 100644 --- a/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs +++ b/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs @@ -1,4 +1,5 @@ using Mockolate.Exceptions; +using Mockolate.Setup; using static Mockolate.Tests.MockMethods.SetupMethodTests; namespace Mockolate.Tests.MockMethods; @@ -48,6 +49,21 @@ public async Task GetHashCode_ShouldWork() await That(mock.VerifyMock.Invoked.GetHashCode()).Once(); } + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task InvokedSetup_WhenSetupWasNotInvoked_ShouldVerifyToNever(int firstParameter, int expectedCallCount) + { + MockTests.IMyService sut = Mock.Create(); + IMethodSetup setup = sut.SetupMock.Method.Subtract( + It.Satisfies(x => x > 0), + It.IsAny()).Returns(1); + + sut.Subtract(firstParameter, 4); + + await That(sut.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task MethodWithDifferentName_ShouldNotMatch() { From d055061a83f3013d9395e443f1eba08b0c463a9c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Valentin=20Breu=C3=9F?= Date: Sat, 28 Feb 2026 14:01:29 +0100 Subject: [PATCH 2/3] Fix sonar issues and simplify MethodSetup implementation --- .../Sources/Sources.MethodSetups.cs | 20 ------------- .../Mockolate/Setup/MethodParameterMatch.cs | 8 +++--- .../Mockolate/Setup/MethodParametersMatch.cs | 6 ++-- Source/Mockolate/Setup/MethodSetup.cs | 7 +---- Source/Mockolate/Setup/ReturnMethodSetup.cs | 28 ------------------- Source/Mockolate/Setup/VoidMethodSetup.cs | 28 ------------------- .../Expected/Mockolate_net10.0.txt | 15 ++-------- .../Expected/Mockolate_net8.0.txt | 15 ++-------- .../Expected/Mockolate_netstandard2.0.txt | 15 ++-------- .../MockMethods/SetupMethodTests.cs | 3 -- 10 files changed, 14 insertions(+), 131 deletions(-) diff --git a/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs b/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs index 5df4caa6..eadc061d 100644 --- a/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs +++ b/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs @@ -573,16 +573,6 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete .AppendLine(); sb.AppendLine(); - sb.Append("\t\t/// ").AppendLine(); - sb.Append("\t\tprotected override bool IsMatch(MethodInvocation invocation)").AppendLine(); - sb.Append("\t\t\t=> invocation.Name.Equals(_name) &&").AppendLine(); - sb.Append("\t\t\t\t(_matches is not null").AppendLine(); - sb.Append("\t\t\t\t\t? _matches.Matches(invocation.Parameters)").AppendLine(); - sb.Append("\t\t\t\t\t: Matches([") - .Append(string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(x => $"_match{x}!"))) - .Append("], invocation.Parameters));").AppendLine(); - sb.AppendLine(); - sb.Append("\t\t/// ").AppendLine(); sb.Append("\t\tprotected override void TriggerParameterCallbacks(object?[] parameters)").AppendLine(); sb.Append("\t\t\t=> TriggerCallbacks([") @@ -1181,16 +1171,6 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame sb.Append("\t\t}").AppendLine(); sb.AppendLine(); - sb.Append("\t\t/// ").AppendLine(); - sb.Append("\t\tprotected override bool IsMatch(MethodInvocation invocation)").AppendLine(); - sb.Append("\t\t\t=> invocation.Name.Equals(_name) &&").AppendLine(); - sb.Append("\t\t\t\t(_matches is not null").AppendLine(); - sb.Append("\t\t\t\t\t? _matches.Matches(invocation.Parameters)").AppendLine(); - sb.Append("\t\t\t\t\t: Matches([") - .Append(string.Join(", ", Enumerable.Range(1, numberOfParameters).Select(x => $"_match{x}!"))) - .Append("], invocation.Parameters));").AppendLine(); - sb.AppendLine(); - sb.Append("\t\t/// ").AppendLine(); sb.Append("\t\tprotected override void TriggerParameterCallbacks(object?[] parameters)").AppendLine(); sb.Append("\t\t\t=> TriggerCallbacks([") diff --git a/Source/Mockolate/Setup/MethodParameterMatch.cs b/Source/Mockolate/Setup/MethodParameterMatch.cs index 896e14ca..d63b0542 100644 --- a/Source/Mockolate/Setup/MethodParameterMatch.cs +++ b/Source/Mockolate/Setup/MethodParameterMatch.cs @@ -16,11 +16,11 @@ namespace Mockolate.Setup; public readonly struct MethodParameterMatch(string methodName, NamedParameter[] parameters) : IMethodMatch { /// - public bool Matches(MethodInvocation method) - => method.Name.Equals(methodName) && - method.Parameters.Length == parameters.Length && + public bool Matches(MethodInvocation methodInvocation) + => methodInvocation.Name.Equals(methodName) && + methodInvocation.Parameters.Length == parameters.Length && !parameters - .Where((parameter, i) => !parameter.Matches(method.Parameters[i])) + .Where((parameter, i) => !parameter.Matches(methodInvocation.Parameters[i])) .Any(); /// diff --git a/Source/Mockolate/Setup/MethodParametersMatch.cs b/Source/Mockolate/Setup/MethodParametersMatch.cs index 3bb1055c..3e7ea48b 100644 --- a/Source/Mockolate/Setup/MethodParametersMatch.cs +++ b/Source/Mockolate/Setup/MethodParametersMatch.cs @@ -14,9 +14,9 @@ namespace Mockolate.Setup; public readonly struct MethodParametersMatch(string methodName, IParameters parameters) : IMethodMatch { /// - public bool Matches(MethodInvocation method) - => method.Name.Equals(methodName) && - parameters.Matches(method.Parameters); + public bool Matches(MethodInvocation methodInvocation) + => methodInvocation.Name.Equals(methodName) && + parameters.Matches(methodInvocation.Parameters); /// public override string ToString() diff --git a/Source/Mockolate/Setup/MethodSetup.cs b/Source/Mockolate/Setup/MethodSetup.cs index 414b7c49..00cf63e4 100644 --- a/Source/Mockolate/Setup/MethodSetup.cs +++ b/Source/Mockolate/Setup/MethodSetup.cs @@ -25,7 +25,7 @@ T IInteractiveMethodSetup.SetRefParameter(string parameterName, T value, Mock /// bool IInteractiveMethodSetup.Matches(MethodInvocation methodInvocation) - => IsMatch(methodInvocation); + => methodMatch.Matches(methodInvocation); /// bool? IInteractiveMethodSetup.SkipBaseClass() @@ -93,11 +93,6 @@ public IMethodMatch GetMatch() protected abstract TResult GetReturnValue(MethodInvocation invocation, MockBehavior behavior, Func defaultValueGenerator); - /// - /// Checks if the matches the setup. - /// - protected abstract bool IsMatch(MethodInvocation invocation); - /// /// Triggers any configured parameter callbacks for the method setup with the specified . /// diff --git a/Source/Mockolate/Setup/ReturnMethodSetup.cs b/Source/Mockolate/Setup/ReturnMethodSetup.cs index fbbef2a3..f16364e2 100644 --- a/Source/Mockolate/Setup/ReturnMethodSetup.cs +++ b/Source/Mockolate/Setup/ReturnMethodSetup.cs @@ -186,10 +186,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, return defaultValueGenerator(); } - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(name) && invocation.Parameters.Length == 0; - /// protected override void TriggerParameterCallbacks(object?[] parameters) { @@ -449,12 +445,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, return defaultValueGenerator(); } - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(_name) && - (_matches?.Matches(invocation.Parameters) - ?? Matches([_match1!,], invocation.Parameters)); - /// protected override void TriggerParameterCallbacks(object?[] parameters) => TriggerCallbacks([_match1,], parameters); @@ -741,12 +731,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, return defaultValueGenerator(); } - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(_name) && - (_matches?.Matches(invocation.Parameters) - ?? Matches([_match1!, _match2!,], invocation.Parameters)); - /// protected override void TriggerParameterCallbacks(object?[] parameters) => TriggerCallbacks([_match1, _match2,], parameters); @@ -1048,12 +1032,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, return defaultValueGenerator(); } - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(_name) && - (_matches?.Matches(invocation.Parameters) - ?? Matches([_match1!, _match2!, _match3!,], invocation.Parameters)); - /// protected override void TriggerParameterCallbacks(object?[] parameters) => TriggerCallbacks([_match1, _match2, _match3,], parameters); @@ -1373,12 +1351,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, return defaultValueGenerator(); } - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(_name) && - (_matches?.Matches(invocation.Parameters) - ?? Matches([_match1!, _match2!, _match3!, _match4!,], invocation.Parameters)); - /// protected override void TriggerParameterCallbacks(object?[] parameters) => TriggerCallbacks([_match1, _match2, _match3, _match4,], parameters); diff --git a/Source/Mockolate/Setup/VoidMethodSetup.cs b/Source/Mockolate/Setup/VoidMethodSetup.cs index 34a73e14..ca994646 100644 --- a/Source/Mockolate/Setup/VoidMethodSetup.cs +++ b/Source/Mockolate/Setup/VoidMethodSetup.cs @@ -167,10 +167,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, where TResult : default => throw new MockException("The method setup does not support return values."); - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(name) && invocation.Parameters.Length == 0; - /// protected override void TriggerParameterCallbacks(object?[] parameters) { @@ -392,12 +388,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, where TResult : default => throw new MockException("The method setup does not support return values."); - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(_name) && - (_matches?.Matches(invocation.Parameters) - ?? Matches([_match1!,], invocation.Parameters)); - /// protected override void TriggerParameterCallbacks(object?[] parameters) => TriggerCallbacks([_match1,], parameters); @@ -638,12 +628,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, where TResult : default => throw new MockException("The method setup does not support return values."); - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(_name) && - (_matches?.Matches(invocation.Parameters) - ?? Matches([_match1!, _match2!,], invocation.Parameters)); - /// protected override void TriggerParameterCallbacks(object?[] parameters) => TriggerCallbacks([_match1, _match2,], parameters); @@ -893,12 +877,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, where TResult : default => throw new MockException("The method setup does not support return values."); - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(_name) && - (_matches?.Matches(invocation.Parameters) - ?? Matches([_match1!, _match2!, _match3!,], invocation.Parameters)); - /// protected override void TriggerParameterCallbacks(object?[] parameters) => TriggerCallbacks([_match1, _match2, _match3,], parameters); @@ -1154,12 +1132,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, where TResult : default => throw new MockException("The method setup does not support return values."); - /// - protected override bool IsMatch(MethodInvocation invocation) - => invocation.Name.Equals(_name) && - (_matches?.Matches(invocation.Parameters) - ?? Matches([_match1!, _match2!, _match3!, _match4!,], invocation.Parameters)); - /// protected override void TriggerParameterCallbacks(object?[] parameters) => TriggerCallbacks([_match1, _match2, _match3, _match4,], parameters); diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt index 19ad3c68..18c2ec80 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt @@ -1408,13 +1408,13 @@ namespace Mockolate.Setup public readonly struct MethodParameterMatch : Mockolate.Setup.IMethodMatch { public MethodParameterMatch(string methodName, Mockolate.Parameters.NamedParameter[] parameters) { } - public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public bool Matches(Mockolate.Interactions.MethodInvocation methodInvocation) { } public override string ToString() { } } public readonly struct MethodParametersMatch : Mockolate.Setup.IMethodMatch { public MethodParametersMatch(string methodName, Mockolate.Parameters.IParameters parameters) { } - public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public bool Matches(Mockolate.Interactions.MethodInvocation methodInvocation) { } public override string ToString() { } } public abstract class MethodSetup : Mockolate.Setup.IInteractiveMethodSetup, Mockolate.Setup.ISetup, Mockolate.Setup.IVerifiableMethodSetup @@ -1425,7 +1425,6 @@ namespace Mockolate.Setup protected abstract TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator); protected abstract bool? GetSkipBaseClass(); protected virtual bool HasReturnCalls() { } - protected abstract bool IsMatch(Mockolate.Interactions.MethodInvocation invocation); protected abstract T SetOutParameter(string parameterName, System.Func defaultValueGenerator); protected abstract T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior); public void TriggerCallbacks(object?[] parameters) { } @@ -1501,7 +1500,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } @@ -1525,7 +1523,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1551,7 +1548,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1577,7 +1573,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1603,7 +1598,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1634,7 +1628,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1656,7 +1649,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1679,7 +1671,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1702,7 +1693,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1725,7 +1715,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt index 6e68bbd4..59e4e993 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt @@ -1407,13 +1407,13 @@ namespace Mockolate.Setup public readonly struct MethodParameterMatch : Mockolate.Setup.IMethodMatch { public MethodParameterMatch(string methodName, Mockolate.Parameters.NamedParameter[] parameters) { } - public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public bool Matches(Mockolate.Interactions.MethodInvocation methodInvocation) { } public override string ToString() { } } public readonly struct MethodParametersMatch : Mockolate.Setup.IMethodMatch { public MethodParametersMatch(string methodName, Mockolate.Parameters.IParameters parameters) { } - public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public bool Matches(Mockolate.Interactions.MethodInvocation methodInvocation) { } public override string ToString() { } } public abstract class MethodSetup : Mockolate.Setup.IInteractiveMethodSetup, Mockolate.Setup.ISetup, Mockolate.Setup.IVerifiableMethodSetup @@ -1424,7 +1424,6 @@ namespace Mockolate.Setup protected abstract TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator); protected abstract bool? GetSkipBaseClass(); protected virtual bool HasReturnCalls() { } - protected abstract bool IsMatch(Mockolate.Interactions.MethodInvocation invocation); protected abstract T SetOutParameter(string parameterName, System.Func defaultValueGenerator); protected abstract T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior); public void TriggerCallbacks(object?[] parameters) { } @@ -1500,7 +1499,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } @@ -1524,7 +1522,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1550,7 +1547,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1576,7 +1572,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1602,7 +1597,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1633,7 +1627,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1655,7 +1648,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1678,7 +1670,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1701,7 +1692,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1724,7 +1714,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt index 14dc3d8a..d994711a 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt @@ -1370,13 +1370,13 @@ namespace Mockolate.Setup public readonly struct MethodParameterMatch : Mockolate.Setup.IMethodMatch { public MethodParameterMatch(string methodName, Mockolate.Parameters.NamedParameter[] parameters) { } - public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public bool Matches(Mockolate.Interactions.MethodInvocation methodInvocation) { } public override string ToString() { } } public readonly struct MethodParametersMatch : Mockolate.Setup.IMethodMatch { public MethodParametersMatch(string methodName, Mockolate.Parameters.IParameters parameters) { } - public bool Matches(Mockolate.Interactions.MethodInvocation method) { } + public bool Matches(Mockolate.Interactions.MethodInvocation methodInvocation) { } public override string ToString() { } } public abstract class MethodSetup : Mockolate.Setup.IInteractiveMethodSetup, Mockolate.Setup.ISetup, Mockolate.Setup.IVerifiableMethodSetup @@ -1387,7 +1387,6 @@ namespace Mockolate.Setup protected abstract TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator); protected abstract bool? GetSkipBaseClass(); protected virtual bool HasReturnCalls() { } - protected abstract bool IsMatch(Mockolate.Interactions.MethodInvocation invocation); protected abstract T SetOutParameter(string parameterName, System.Func defaultValueGenerator); protected abstract T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior); public void TriggerCallbacks(object?[] parameters) { } @@ -1456,7 +1455,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } @@ -1480,7 +1478,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1506,7 +1503,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1532,7 +1528,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1558,7 +1553,6 @@ namespace Mockolate.Setup protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } protected override bool HasReturnCalls() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(System.Func callback) { } public Mockolate.Setup.IReturnMethodSetupReturnBuilder Returns(TReturn returnValue) { } @@ -1582,7 +1576,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1604,7 +1597,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1627,7 +1619,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1650,7 +1641,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } @@ -1673,7 +1663,6 @@ namespace Mockolate.Setup protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { } protected override TResult GetReturnValue(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func defaultValueGenerator) { } protected override bool? GetSkipBaseClass() { } - protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { } protected override T SetOutParameter(string parameterName, System.Func defaultValueGenerator) { } protected override T SetRefParameter(string parameterName, T value, Mockolate.MockBehavior behavior) { } public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { } diff --git a/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs b/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs index 2be7a605..0ea19353 100644 --- a/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs +++ b/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs @@ -1172,9 +1172,6 @@ protected override TResult GetReturnValue(MethodInvocation invocation, Func defaultValueGenerator) => throw new NotSupportedException(); - protected override bool IsMatch(MethodInvocation invocation) - => throw new NotSupportedException(); - protected override void TriggerParameterCallbacks(object?[] parameters) => throw new NotSupportedException(); } From fc7600a914e61351aaad7552ad55e620353def22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Valentin=20Breu=C3=9F?= Date: Sat, 28 Feb 2026 14:29:21 +0100 Subject: [PATCH 3/3] Fix review issues --- .../Sources/Sources.MethodSetups.cs | 4 +- Source/Mockolate/MockExtensions.cs | 12 +- .../Mockolate/Setup/Interfaces.MethodSetup.cs | 10 +- .../Expected/Mockolate_net10.0.txt | 60 +++---- .../Expected/Mockolate_net8.0.txt | 60 +++---- .../Expected/Mockolate_netstandard2.0.txt | 60 +++---- ...ensionsTests.ClearAllInteractionsTests.cs} | 2 +- .../MockExtensionsTests.InvokedSetupTests.cs | 56 ++++++ .../MockMethods/SetupMethodTests.cs | 160 ++++++++++++++++++ .../MockMethods/VerifyInvokedTests.cs | 2 +- 10 files changed, 323 insertions(+), 103 deletions(-) rename Tests/Mockolate.Tests/{MockExtensionsTests.cs => MockExtensionsTests.ClearAllInteractionsTests.cs} (98%) create mode 100644 Tests/Mockolate.Tests/MockExtensionsTests.InvokedSetupTests.cs diff --git a/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs b/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs index eadc061d..705f992f 100644 --- a/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs +++ b/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs @@ -113,7 +113,7 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete sb.AppendXmlSummary( $"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", "\t"); - sb.Append("\tinternal interface IVoidMethodSetup<").Append(typeParams).Append(">").AppendLine(); + sb.Append("\tinternal interface IVoidMethodSetup<").Append(typeParams).Append("> : IMethodSetup").AppendLine(); sb.Append("\t{").AppendLine(); sb.AppendXmlSummary("Specifies if calling the base class implementation should be skipped."); sb.AppendXmlRemarks("If not specified, use ."); @@ -646,7 +646,7 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame sb.AppendXmlSummary( $"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning .", "\t"); - sb.Append("\tinternal interface IReturnMethodSetup") + sb.Append("\tinternal interface IReturnMethodSetup : IMethodSetup") .AppendLine(); sb.Append("\t{").AppendLine(); sb.AppendXmlSummary("Specifies if calling the base class implementation should be skipped."); diff --git a/Source/Mockolate/MockExtensions.cs b/Source/Mockolate/MockExtensions.cs index f7b4dacd..6b374b36 100644 --- a/Source/Mockolate/MockExtensions.cs +++ b/Source/Mockolate/MockExtensions.cs @@ -26,12 +26,16 @@ public static void ClearAllInteractions(this IMockSetup mock) /// public static VerificationResult InvokedSetup(this IMockVerify verify, IMethodSetup setup) { - if (setup is IVerifiableMethodSetup verifiableMethodSetup && - verify is Mock mock) + if (verify is not Mock mock) { - return mock.Registrations.Method(mock.Subject, verifiableMethodSetup.GetMatch()); + throw new MockException("The subject is no mock subject."); } - throw new MockException("The subject is no mock."); + if (setup is not IVerifiableMethodSetup verifiableMethodSetup) + { + throw new MockException("The setup is not verifiable."); + } + + return mock.Registrations.Method(mock.Subject, verifiableMethodSetup.GetMatch()); } } diff --git a/Source/Mockolate/Setup/Interfaces.MethodSetup.cs b/Source/Mockolate/Setup/Interfaces.MethodSetup.cs index 92abb66a..5af6e168 100644 --- a/Source/Mockolate/Setup/Interfaces.MethodSetup.cs +++ b/Source/Mockolate/Setup/Interfaces.MethodSetup.cs @@ -872,7 +872,7 @@ public interface IReturnMethodSetupReturnWhenBuilder /// Sets up a method returning . /// -public interface IVoidMethodSetup +public interface IVoidMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. @@ -1005,7 +1005,7 @@ public interface IVoidMethodSetupReturnWhenBuilder : IVoidMethodSetup /// /// Sets up a method returning . /// -public interface IVoidMethodSetup +public interface IVoidMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. @@ -1152,7 +1152,7 @@ public interface IVoidMethodSetupReturnWhenBuilder /// /// Sets up a method returning . /// -public interface IVoidMethodSetup +public interface IVoidMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. @@ -1299,7 +1299,7 @@ public interface IVoidMethodSetupReturnWhenBuilder /// /// Sets up a method returning . /// -public interface IVoidMethodSetup +public interface IVoidMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. @@ -1446,7 +1446,7 @@ public interface IVoidMethodSetupReturnWhenBuilder /// /// Sets up a method returning . /// -public interface IVoidMethodSetup +public interface IVoidMethodSetup : IMethodSetup { /// /// Specifies if calling the base class implementation should be skipped. diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt index 18c2ec80..7edfbf5d 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt @@ -1129,7 +1129,7 @@ namespace Mockolate.Setup { Mockolate.Setup.IMethodMatch GetMatch(); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1140,102 +1140,102 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1248,7 +1248,7 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1261,7 +1261,7 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1274,7 +1274,7 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1619,7 +1619,7 @@ namespace Mockolate.Setup public static System.Span op_Implicit(Mockolate.Setup.SpanWrapper wrapper) { } public static Mockolate.Setup.SpanWrapper op_Implicit(System.Span span) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder { public VoidMethodSetup(string name) { } public Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback) { } @@ -1638,7 +1638,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { } @@ -1660,7 +1660,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { } @@ -1682,7 +1682,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { } @@ -1704,7 +1704,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3, Mockolate.Parameters.NamedParameter match4) { } diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt index 59e4e993..8199b859 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt @@ -1128,7 +1128,7 @@ namespace Mockolate.Setup { Mockolate.Setup.IMethodMatch GetMatch(); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1139,102 +1139,102 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1247,7 +1247,7 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1260,7 +1260,7 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1273,7 +1273,7 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1618,7 +1618,7 @@ namespace Mockolate.Setup public static System.Span op_Implicit(Mockolate.Setup.SpanWrapper wrapper) { } public static Mockolate.Setup.SpanWrapper op_Implicit(System.Span span) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder { public VoidMethodSetup(string name) { } public Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback) { } @@ -1637,7 +1637,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { } @@ -1659,7 +1659,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { } @@ -1681,7 +1681,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { } @@ -1703,7 +1703,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3, Mockolate.Parameters.NamedParameter match4) { } diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt index d994711a..715d3b1c 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt @@ -1091,7 +1091,7 @@ namespace Mockolate.Setup { Mockolate.Setup.IMethodMatch GetMatch(); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1102,102 +1102,102 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder InParallel(); Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupCallbackWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder When(System.Func predicate); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IVoidMethodSetup + public interface IVoidMethodSetupReturnWhenBuilder : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup { Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder For(int times); Mockolate.Setup.IVoidMethodSetup Only(int times); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1210,7 +1210,7 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1223,7 +1223,7 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1236,7 +1236,7 @@ namespace Mockolate.Setup Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws() where TException : System.Exception, new (); } - public interface IVoidMethodSetup + public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup { Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback); @@ -1567,7 +1567,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder { public VoidMethodSetup(string name) { } public Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback) { } @@ -1586,7 +1586,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { } @@ -1608,7 +1608,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { } @@ -1630,7 +1630,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { } @@ -1652,7 +1652,7 @@ namespace Mockolate.Setup public override string ToString() { } protected override void TriggerParameterCallbacks(object?[] parameters) { } } - public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup + public class VoidMethodSetup : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder, Mockolate.Setup.IVoidMethodSetupReturnBuilder, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder, Mockolate.Setup.IVoidMethodSetup { public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { } public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3, Mockolate.Parameters.NamedParameter match4) { } diff --git a/Tests/Mockolate.Tests/MockExtensionsTests.cs b/Tests/Mockolate.Tests/MockExtensionsTests.ClearAllInteractionsTests.cs similarity index 98% rename from Tests/Mockolate.Tests/MockExtensionsTests.cs rename to Tests/Mockolate.Tests/MockExtensionsTests.ClearAllInteractionsTests.cs index 87eeaa4a..83450450 100644 --- a/Tests/Mockolate.Tests/MockExtensionsTests.cs +++ b/Tests/Mockolate.Tests/MockExtensionsTests.ClearAllInteractionsTests.cs @@ -3,7 +3,7 @@ namespace Mockolate.Tests; -public sealed class MockExtensionsTests +public sealed partial class MockExtensionsTests { public sealed class ClearAllInteractionsTests { diff --git a/Tests/Mockolate.Tests/MockExtensionsTests.InvokedSetupTests.cs b/Tests/Mockolate.Tests/MockExtensionsTests.InvokedSetupTests.cs new file mode 100644 index 00000000..45722331 --- /dev/null +++ b/Tests/Mockolate.Tests/MockExtensionsTests.InvokedSetupTests.cs @@ -0,0 +1,56 @@ +using Mockolate.Exceptions; +using Mockolate.Setup; +using Mockolate.Tests.TestHelpers; +using Mockolate.Verify; + +namespace Mockolate.Tests; + +public sealed partial class MockExtensionsTests +{ + public sealed class InvokedSetupTests + { + [Fact] + public async Task WhenMethodSetupIsNotVerifiable_ShouldThrowMockException() + { + MyServiceBase mock = Mock.Create(); + IMethodSetup setup = new MyMethodSetup(); + + void Act() + { + mock.VerifyMock.InvokedSetup(setup).Never(); + } + + await That(Act).Throws() + .WithMessage("The setup is not verifiable."); + } + + [Fact] + public async Task WhenSubjectIsNoMock_ShouldThrowMockException() + { + MyServiceBase mock = Mock.Create(); + IMockVerify verify = new MyMockVerify(); + IMethodSetup setup = mock.SetupMock.Method.DoSomething(Match.AnyParameters()); + + void Act() + { + verify.InvokedSetup(setup).Never(); + } + + await That(Act).Throws() + .WithMessage("The subject is no mock subject."); + } + + private sealed class MyMockVerify : IMockVerify + { + public bool ThatAllInteractionsAreVerified() + => throw new NotSupportedException(); + + public bool ThatAllSetupsAreUsed() + => throw new NotSupportedException(); + } + + private sealed class MyMethodSetup : IMethodSetup + { + } + } +} diff --git a/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs b/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs index 0ea19353..785398eb 100644 --- a/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs +++ b/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs @@ -751,6 +751,17 @@ public async Task WithRefReadonlyParameter_ShouldUseSetup() public class ReturnMethodWith0Parameters { + [Fact] + public async Task Setup_ShouldBeVerifiable() + { + IReturnMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method0(); + + mock.Method0(); + + await That(mock.VerifyMock.InvokedSetup(setup)).Once(); + } + [Fact] public async Task ToString_ShouldReturnMethodSignature() { @@ -780,6 +791,19 @@ public async Task WhenSetupWithNull_ShouldReturnDefaultValue() public class ReturnMethodWith1Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IReturnMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method1(It.Satisfies(x => x > 0)); + + mock.Method1(firstParameter); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { @@ -820,6 +844,20 @@ public async Task WhenSetupWithNull_ShouldReturnDefaultValue() public class ReturnMethodWith2Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IReturnMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method2( + It.Satisfies(x => x > 0), It.IsAny()); + + mock.Method2(firstParameter, 2); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { @@ -861,6 +899,20 @@ public async Task WhenSetupWithNull_ShouldReturnDefaultValue() public class ReturnMethodWith3Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IReturnMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method3( + It.Satisfies(x => x > 0), It.IsAny(), It.IsAny()); + + mock.Method3(firstParameter, 2, 3); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { @@ -903,6 +955,20 @@ public async Task WhenSetupWithNull_ShouldReturnDefaultValue() public class ReturnMethodWith4Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IReturnMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method4( + It.Satisfies(x => x > 0), It.IsAny(), It.IsAny(), It.IsAny()); + + mock.Method4(firstParameter, 2, 3, 4); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { @@ -948,6 +1014,20 @@ public async Task WhenSetupWithNull_ShouldReturnDefaultValue() public class ReturnMethodWith5Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IReturnMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method5( + It.Satisfies(x => x > 0), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()); + + mock.Method5(firstParameter, 2, 3, 4, 5); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { @@ -995,6 +1075,17 @@ public async Task WhenSetupWithNull_ShouldReturnDefaultValue() public class VoidMethodWith0Parameters { + [Fact] + public async Task Setup_ShouldBeVerifiable() + { + IVoidMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method0(); + + mock.Method0(); + + await That(mock.VerifyMock.InvokedSetup(setup)).Once(); + } + [Fact] public async Task ToString_ShouldReturnMethodSignature() { @@ -1008,6 +1099,19 @@ public async Task ToString_ShouldReturnMethodSignature() public class VoidMethodWith1Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IVoidMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method1(It.Satisfies(x => x > 0)); + + mock.Method1(firstParameter); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { @@ -1032,6 +1136,20 @@ public async Task ToString_ShouldReturnMethodSignature() public class VoidMethodWith2Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IVoidMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method2( + It.Satisfies(x => x > 0), It.IsAny()); + + mock.Method2(firstParameter, 2); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { @@ -1057,6 +1175,20 @@ public async Task ToString_ShouldReturnMethodSignature() public class VoidMethodWith3Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IVoidMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method3( + It.Satisfies(x => x > 0), It.IsAny(), It.IsAny()); + + mock.Method3(firstParameter, 2, 3); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { @@ -1083,6 +1215,20 @@ public async Task ToString_ShouldReturnMethodSignature() public class VoidMethodWith4Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IVoidMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method4( + It.Satisfies(x => x > 0), It.IsAny(), It.IsAny(), It.IsAny()); + + mock.Method4(firstParameter, 2, 3, 4); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { @@ -1112,6 +1258,20 @@ await That(result) public class VoidMethodWith5Parameters { + [Theory] + [InlineData(-1, 0)] + [InlineData(1, 1)] + public async Task Setup_ShouldBeVerifiable(int firstParameter, int expectedCallCount) + { + IVoidMethodSetupTest mock = Mock.Create(); + IMethodSetup setup = mock.SetupMock.Method.Method5( + It.Satisfies(x => x > 0), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()); + + mock.Method5(firstParameter, 2, 3, 4, 5); + + await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount); + } + [Fact] public async Task ToString_AnyParameters_ShouldReturnMethodSignature() { diff --git a/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs b/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs index fcbebe78..c2f766a9 100644 --- a/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs +++ b/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs @@ -52,7 +52,7 @@ public async Task GetHashCode_ShouldWork() [Theory] [InlineData(-1, 0)] [InlineData(1, 1)] - public async Task InvokedSetup_WhenSetupWasNotInvoked_ShouldVerifyToNever(int firstParameter, int expectedCallCount) + public async Task InvokedSetup_ShouldVerifySameConditionAsSetup(int firstParameter, int expectedCallCount) { MockTests.IMyService sut = Mock.Create(); IMethodSetup setup = sut.SetupMock.Method.Subtract(