diff --git a/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs b/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs
index 95dce0c9..705f992f 100644
--- a/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs
+++ b/Source/Mockolate.SourceGenerators/Sources/Sources.MethodSetups.cs
@@ -110,8 +110,10 @@ 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 <see langword=\"void\" />.", "\t");
-		sb.Append("\tinternal interface IVoidMethodSetup<").Append(typeParams).Append(">").AppendLine();
+		sb.AppendXmlSummary(
+			$"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <see langword=\"void\" />.",
+			"\t");
+		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 <see cref=\"MockBehavior.SkipBaseClass\" />.");
@@ -150,32 +152,40 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete
 			.AppendLine();
 		sb.AppendLine();
 
-		sb.AppendXmlSummary("Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
+		sb.AppendXmlSummary(
+			"Registers a <paramref name=\"callback\" /> 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 <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
+		sb.AppendXmlSummary(
+			"Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
 		sb.Append("\t\tIVoidMethodSetupReturnBuilder<").Append(typeParams).Append("> Throws(Func<Exception> callback);")
 			.AppendLine();
 		sb.Append("}").AppendLine();
 		sb.AppendLine();
 
-		sb.AppendXmlSummary($"Sets up a callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <see langword=\"void\" />.", "");
+		sb.AppendXmlSummary(
+			$"Sets up a callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <see langword=\"void\" />.",
+			"");
 		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<int, bool> predicate);").AppendLine();
 		sb.Append("}").AppendLine();
 		sb.AppendLine();
 
-		sb.AppendXmlSummary($"Sets up a when callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <see langword=\"void\" />.", "");
+		sb.AppendXmlSummary(
+			$"Sets up a when callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <see langword=\"void\" />.",
+			"");
 		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 <see langword=\"void\" />.", "");
+		sb.AppendXmlSummary(
+			$"Sets up a return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <see langword=\"void\" />.",
+			"");
 		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<int, bool> predicate);").AppendLine();
 		sb.Append("}").AppendLine();
 		sb.AppendLine();
 
-		sb.AppendXmlSummary($"Sets up a when return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <see langword=\"void\" />.", "");
+		sb.AppendXmlSummary(
+			$"Sets up a when return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <see langword=\"void\" />.",
+			"");
 		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 <see langword=\"void\" />.", "");
+		sb.AppendXmlSummary(
+			$"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <see langword=\"void\" />.",
+			"");
 		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 <see cref=\"MockBehavior.SkipBaseClass\" />.");
 		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 <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
+		sb.AppendXmlSummary(
+			"Registers a <paramref name=\"callback\" /> 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 <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
+		sb.AppendXmlSummary(
+			"Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
 		sb.Append("\t\tpublic IVoidMethodSetupReturnBuilder<").Append(typeParams)
 			.Append("> Throws(Func<Exception> callback)")
 			.AppendLine();
@@ -549,16 +573,6 @@ private static void AppendVoidMethodSetup(StringBuilder sb, int numberOfParamete
 			.AppendLine();
 		sb.AppendLine();
 
-		sb.Append("\t\t/// <inheritdoc cref=\"MethodSetup.IsMatch(MethodInvocation)\" />").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/// <inheritdoc cref=\"MethodSetup.TriggerParameterCallbacks(object?[])\" />").AppendLine();
 		sb.Append("\t\tprotected override void TriggerParameterCallbacks(object?[] parameters)").AppendLine();
 		sb.Append("\t\t\t=> TriggerCallbacks([")
@@ -629,8 +643,10 @@ 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 <typeparamref name=\"TReturn\" />.", "\t");
-		sb.Append("\tinternal interface IReturnMethodSetup<TReturn, ").Append(typeParams).Append(">")
+		sb.AppendXmlSummary(
+			$"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <typeparamref name=\"TReturn\" />.",
+			"\t");
+		sb.Append("\tinternal interface IReturnMethodSetup<TReturn, ").Append(typeParams).Append("> : IMethodSetup")
 			.AppendLine();
 		sb.Append("\t{").AppendLine();
 		sb.AppendXmlSummary("Specifies if calling the base class implementation should be skipped.");
@@ -683,18 +699,22 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame
 			.AppendLine();
 		sb.AppendLine();
 
-		sb.AppendXmlSummary("Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
+		sb.AppendXmlSummary(
+			"Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
 		sb.Append("\t\tIReturnMethodSetupReturnBuilder<TReturn, ").Append(typeParams).Append("> Throws(Func<")
 			.Append(typeParams).Append(", Exception> callback);").AppendLine();
 		sb.AppendLine();
 
-		sb.AppendXmlSummary("Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
+		sb.AppendXmlSummary(
+			"Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
 		sb.Append("\t\tIReturnMethodSetupReturnBuilder<TReturn, ").Append(typeParams)
 			.Append("> Throws(Func<Exception> callback);").AppendLine();
 		sb.Append("\t}").AppendLine();
 		sb.AppendLine();
 
-		sb.AppendXmlSummary($"Sets up a callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <typeparamref name=\"TReturn\" />.", "\t");
+		sb.AppendXmlSummary(
+			$"Sets up a callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <typeparamref name=\"TReturn\" />.",
+			"\t");
 		sb.Append("\tinternal interface IReturnMethodSetupCallbackBuilder<TReturn, ").Append(typeParams)
 			.Append("> : IReturnMethodSetupCallbackWhenBuilder<TReturn, ").Append(typeParams).Append(">")
 			.AppendLine();
@@ -703,63 +723,79 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame
 		sb.Append("\t\tIReturnMethodSetupCallbackBuilder<TReturn, ").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\tIReturnMethodSetupCallbackWhenBuilder<TReturn, ").Append(typeParams)
 			.Append("> When(Func<int, bool> predicate);").AppendLine();
 		sb.Append("\t}").AppendLine();
 		sb.AppendLine();
-		
-		sb.AppendXmlSummary($"Sets up a when callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <typeparamref name=\"TReturn\" />.", "\t");
+
+		sb.AppendXmlSummary(
+			$"Sets up a when callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <typeparamref name=\"TReturn\" />.",
+			"\t");
 		sb.Append("\tinternal interface IReturnMethodSetupCallbackWhenBuilder<TReturn, ").Append(typeParams)
 			.Append("> : IReturnMethodSetup<TReturn, ").Append(typeParams).Append(">")
 			.AppendLine();
 		sb.Append("\t{").AppendLine();
-		
+
 		sb.AppendXmlSummary("Repeats the callback for the given number of <paramref name=\"times\" />.");
-		sb.AppendXmlRemarks($"The number of times is only counted for actual executions (<see cref=\"IReturnMethodSetupCallbackBuilder{{TReturn, {typeParams}}}.When(Func{{int, bool}})\" /> evaluates to <see langword=\"true\" />).");
+		sb.AppendXmlRemarks(
+			$"The number of times is only counted for actual executions (<see cref=\"IReturnMethodSetupCallbackBuilder{{TReturn, {typeParams}}}.When(Func{{int, bool}})\" /> evaluates to <see langword=\"true\" />).");
 		sb.Append("\t\tIReturnMethodSetupCallbackWhenBuilder<TReturn, ").Append(typeParams).Append("> For(int times);")
 			.AppendLine();
 		sb.AppendLine();
-		
+
 		sb.AppendXmlSummary("Deactivates the callback after the given number of <paramref name=\"times\" />.");
-		sb.AppendXmlRemarks($"The number of times is only counted for actual executions (<see cref=\"IReturnMethodSetupCallbackBuilder{{TReturn, {typeParams}}}.When(Func{{int, bool}})\" /> evaluates to <see langword=\"true\" />).");
+		sb.AppendXmlRemarks(
+			$"The number of times is only counted for actual executions (<see cref=\"IReturnMethodSetupCallbackBuilder{{TReturn, {typeParams}}}.When(Func{{int, bool}})\" /> evaluates to <see langword=\"true\" />).");
 		sb.Append("\t\tIReturnMethodSetup<TReturn, ").Append(typeParams).Append("> 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 <typeparamref name=\"TReturn\" />.", "\t");
+		sb.AppendXmlSummary(
+			$"Sets up a return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <typeparamref name=\"TReturn\" />.",
+			"\t");
 		sb.Append("\tinternal interface IReturnMethodSetupReturnBuilder<TReturn, ").Append(typeParams)
 			.Append("> : IReturnMethodSetupReturnWhenBuilder<TReturn, ").Append(typeParams).Append(">")
 			.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<TReturn, ").Append(typeParams)
 			.Append("> When(Func<int, bool> 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 <typeparamref name=\"TReturn\" />.", "\t");
+		sb.AppendXmlSummary(
+			$"Sets up a when return callback for a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <typeparamref name=\"TReturn\" />.",
+			"\t");
 		sb.Append("\tinternal interface IReturnMethodSetupReturnWhenBuilder<TReturn, ").Append(typeParams)
 			.Append("> : IReturnMethodSetup<TReturn, ").Append(typeParams).Append(">")
 			.AppendLine();
 		sb.Append("\t{").AppendLine();
-		
+
 		sb.AppendXmlSummary("Repeats the callback for the given number of <paramref name=\"times\" />.");
-		sb.AppendXmlRemarks($"The number of times is only counted for actual executions (<see cref=\"IReturnMethodSetupReturnBuilder{{TReturn, {typeParams}}}.When(Func{{int, bool}})\" /> evaluates to <see langword=\"true\" />).");
+		sb.AppendXmlRemarks(
+			$"The number of times is only counted for actual executions (<see cref=\"IReturnMethodSetupReturnBuilder{{TReturn, {typeParams}}}.When(Func{{int, bool}})\" /> evaluates to <see langword=\"true\" />).");
 		sb.Append("\t\tIReturnMethodSetupReturnWhenBuilder<TReturn, ").Append(typeParams).Append("> For(int times);")
 			.AppendLine();
 		sb.AppendLine();
 		sb.AppendXmlSummary("Deactivates the return/throw after the given number of <paramref name=\"times\" />.");
-		sb.AppendXmlRemarks($"The number of times is only counted for actual executions (<see cref=\"IReturnMethodSetupReturnBuilder{{TReturn, {typeParams}}}.When(Func{{int, bool}})\" /> evaluates to <see langword=\"true\" />).");
+		sb.AppendXmlRemarks(
+			$"The number of times is only counted for actual executions (<see cref=\"IReturnMethodSetupReturnBuilder{{TReturn, {typeParams}}}.When(Func{{int, bool}})\" /> evaluates to <see langword=\"true\" />).");
 		sb.Append("\t\tIReturnMethodSetup<TReturn, ").Append(typeParams).Append("> Only(int times);").AppendLine();
 		sb.Append("\t}").AppendLine();
 		sb.AppendLine();
-		
-		sb.AppendXmlSummary($"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <typeparamref name=\"TReturn\" />.", "\t");
+
+		sb.AppendXmlSummary(
+			$"Sets up a method with {numberOfParameters} parameters {GetTypeParametersDescription(numberOfParameters)} returning <typeparamref name=\"TReturn\" />.",
+			"\t");
 		sb.Append("\tinternal class ReturnMethodSetup<TReturn, ").Append(typeParams)
 			.Append("> : MethodSetup,").AppendLine();
 		sb.Append("\t\tIReturnMethodSetupCallbackBuilder<TReturn, ").Append(typeParams).Append(">,").AppendLine();
@@ -795,6 +831,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 +848,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 +973,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 <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
+
+		sb.AppendXmlSummary(
+			"Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
 		sb.Append("\t\tpublic IReturnMethodSetupReturnBuilder<TReturn, ").Append(typeParams).Append("> Throws(Func<")
 			.Append(typeParams).Append(", Exception> callback)").AppendLine();
 		sb.Append("\t\t{").AppendLine();
@@ -948,7 +989,8 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame
 		sb.Append("\t\t}").AppendLine();
 		sb.AppendLine();
 
-		sb.AppendXmlSummary("Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
+		sb.AppendXmlSummary(
+			"Registers a <paramref name=\"callback\" /> that will calculate the exception to throw when the method is invoked.");
 		sb.Append("\t\tpublic IReturnMethodSetupReturnBuilder<TReturn, ").Append(typeParams)
 			.Append("> Throws(Func<Exception> callback)")
 			.AppendLine();
@@ -1129,16 +1171,6 @@ private static void AppendReturnMethodSetup(StringBuilder sb, int numberOfParame
 		sb.Append("\t\t}").AppendLine();
 		sb.AppendLine();
 
-		sb.Append("\t\t/// <inheritdoc cref=\"MethodSetup.IsMatch(MethodInvocation)\" />").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/// <inheritdoc cref=\"MethodSetup.TriggerParameterCallbacks(object?[])\" />").AppendLine();
 		sb.Append("\t\tprotected override void TriggerParameterCallbacks(object?[] parameters)").AppendLine();
 		sb.Append("\t\t\t=> TriggerCallbacks([")
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<T>.ThatAllSetupsAreUsed()
 
 	/// <inheritdoc cref="IMockVerifyInvokedWithToString{T}.ToString()" />
 	VerificationResult<T> IMockVerifyInvokedWithToString<T>.ToString()
-		=> Registrations.Method(Subject, Registrations.Prefix + ".ToString");
+		=> Registrations.Method(Subject, new MethodParameterMatch(Registrations.Prefix + ".ToString", []));
 
 	/// <inheritdoc cref="IMockVerifyInvokedWithEquals{T}.Equals(IParameter{object?})" />
 	VerificationResult<T> IMockVerifyInvokedWithEquals<T>.Equals(IParameter<object?>? obj)
-		=> Registrations.Method(Subject, Registrations.Prefix + ".Equals",
-			new NamedParameter("obj", (IParameter)(obj ?? It.IsNull<object>())));
+		=> Registrations.Method(Subject, new MethodParameterMatch(Registrations.Prefix + ".Equals",
+			[new NamedParameter("obj", (IParameter)(obj ?? It.IsNull<object>())),]));
 
 	/// <inheritdoc cref="IMockVerifyInvokedWithGetHashCode{T}.GetHashCode()" />
 	VerificationResult<T> IMockVerifyInvokedWithGetHashCode<T>.GetHashCode()
-		=> Registrations.Method(Subject, Registrations.Prefix + ".GetHashCode");
+		=> Registrations.Method(Subject, new MethodParameterMatch(Registrations.Prefix + ".GetHashCode", []));
 
 	/// <summary>
 	///     Counts the invocations of method <paramref name="methodName" /> with matching <paramref name="parameters" />.
 	/// </summary>
 	public VerificationResult<T> Method(string methodName, params NamedParameter[] parameters)
-		=> Registrations.Method(Subject, methodName, parameters);
+		=> Registrations.Method(Subject, new MethodParameterMatch(methodName, parameters));
 
 	/// <summary>
 	///     Counts the invocations of method <paramref name="methodName" /> with matching <paramref name="parameters" />.
 	/// </summary>
 	public VerificationResult<T> Method(string methodName, IParameters parameters)
-		=> Registrations.Method(Subject, methodName, parameters);
+		=> Registrations.Method(Subject, new MethodParametersMatch(methodName, parameters));
 
 	/// <summary>
 	///     Counts the getter accesses of property <paramref name="propertyName" />.
diff --git a/Source/Mockolate/MockExtensions.cs b/Source/Mockolate/MockExtensions.cs
index 6a8f9c79..6b374b36 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,22 @@ public static void ClearAllInteractions<T>(this IMockSetup<T> mock)
 			hasMockRegistration.Registrations.ClearAllInteractions();
 		}
 	}
+
+	/// <summary>
+	///     Verifies the method invocations for the <paramref name="setup" /> on the mock.
+	/// </summary>
+	public static VerificationResult<T> InvokedSetup<T>(this IMockVerify<T> verify, IMethodSetup setup)
+	{
+		if (verify is not Mock<T> mock)
+		{
+			throw new MockException("The subject is no mock subject.");
+		}
+
+		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/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
 {
 	/// <summary>
-	///     Counts the invocations of method <paramref name="methodName" /> with matching <paramref name="parameters" /> on the
-	///     <paramref name="subject" />.
+	///     Counts the invocations of methods matching the <paramref name="methodMatch" /> on the <paramref name="subject" />.
 	/// </summary>
-	public VerificationResult<T> Method<T>(T subject, string methodName, params NamedParameter[] parameters)
+	public VerificationResult<T> Method<T>(T subject, IMethodMatch methodMatch)
 		=> new(
 			subject,
 			Interactions,
 			Interactions.Interactions
 				.OfType<MethodInvocation>()
-				.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<IInteraction>()
 				.ToArray(),
-			$"invoked method {methodName.SubstringAfterLast('.')}({string.Join(", ", parameters.Select(x => x.Parameter.ToString()))})");
-
-	/// <summary>
-	///     Counts the invocations of method <paramref name="methodName" /> with matching <paramref name="parameters" /> on the
-	///     <paramref name="subject" />.
-	/// </summary>
-	public VerificationResult<T> Method<T>(T subject, string methodName, IParameters parameters) => new(subject,
-		Interactions,
-		Interactions.Interactions
-			.OfType<MethodInvocation>()
-			.Where(method => method.Name.Equals(methodName) &&
-			                 parameters.Matches(method.Parameters))
-			.Cast<IInteraction>()
-			.ToArray(),
-		$"invoked method {methodName.SubstringAfterLast('.')}({parameters})");
+			$"invoked method {methodMatch}");
 
 	/// <summary>
 	///     Counts the getter accesses of property <paramref name="propertyName" /> on the <paramref name="subject" />.
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;
+
+/// <summary>
+///     A method match to verify method invocations from a setup.
+/// </summary>
+public interface IMethodMatch
+{
+	/// <summary>
+	///     Checks if the <paramref name="methodInvocation" /> matches.
+	/// </summary>
+	bool Matches(MethodInvocation methodInvocation);
+}
diff --git a/Source/Mockolate/Setup/Interfaces.MethodSetup.cs b/Source/Mockolate/Setup/Interfaces.MethodSetup.cs
index 8a2c6aba..5af6e168 100644
--- a/Source/Mockolate/Setup/Interfaces.MethodSetup.cs
+++ b/Source/Mockolate/Setup/Interfaces.MethodSetup.cs
@@ -3,6 +3,23 @@
 
 namespace Mockolate.Setup;
 
+/// <summary>
+///     Marker interface for method setups.
+/// </summary>
+public interface IMethodSetup;
+
+/// <summary>
+///     Interface for verifiable method setup. It hides the implementation details to get the underlying
+///     <see cref="IMethodMatch" />.
+/// </summary>
+public interface IVerifiableMethodSetup
+{
+	/// <summary>
+	///     Gets the <see cref="IMethodMatch" /> used to match against method invocations.
+	/// </summary>
+	IMethodMatch GetMatch();
+}
+
 /// <summary>
 ///     Interface for hiding some implementation details of <see cref="MethodSetup" />.
 /// </summary>
@@ -63,7 +80,7 @@ TResult Invoke<TResult>(MethodInvocation methodInvocation, MockBehavior behavior
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn>
+public interface IReturnMethodSetup<in TReturn> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -209,7 +226,7 @@ public interface IReturnMethodSetupReturnWhenBuilder<in TReturn>
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn, out T1>
+public interface IReturnMethodSetup<in TReturn, out T1> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -370,7 +387,7 @@ public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1>
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn, out T1, out T2>
+public interface IReturnMethodSetup<in TReturn, out T1, out T2> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -531,7 +548,7 @@ public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2>
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3>
+public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -693,7 +710,7 @@ public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2,
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4>
+public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -855,7 +872,7 @@ public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2,
 /// <summary>
 ///     Sets up a method returning <see langword="void" />.
 /// </summary>
-public interface IVoidMethodSetup
+public interface IVoidMethodSetup : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -988,7 +1005,7 @@ public interface IVoidMethodSetupReturnWhenBuilder : IVoidMethodSetup
 /// <summary>
 ///     Sets up a method returning <see langword="void" />.
 /// </summary>
-public interface IVoidMethodSetup<out T1>
+public interface IVoidMethodSetup<out T1> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -1135,7 +1152,7 @@ public interface IVoidMethodSetupReturnWhenBuilder<out T1>
 /// <summary>
 ///     Sets up a method returning <see langword="void" />.
 /// </summary>
-public interface IVoidMethodSetup<out T1, out T2>
+public interface IVoidMethodSetup<out T1, out T2> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -1282,7 +1299,7 @@ public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2>
 /// <summary>
 ///     Sets up a method returning <see langword="void" />.
 /// </summary>
-public interface IVoidMethodSetup<out T1, out T2, out T3>
+public interface IVoidMethodSetup<out T1, out T2, out T3> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -1429,7 +1446,7 @@ public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3>
 /// <summary>
 ///     Sets up a method returning <see langword="void" />.
 /// </summary>
-public interface IVoidMethodSetup<out T1, out T2, out T3, out T4>
+public interface IVoidMethodSetup<out T1, out T2, out T3, out T4> : IMethodSetup
 {
 	/// <summary>
 	///     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..d63b0542
--- /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;
+
+/// <summary>
+///     Matches a method by name and parameters.
+/// </summary>
+/// <remarks>
+///     During verification, the <paramref name="methodName" /> is compared to the method name of the method invocation,
+///     and the <paramref name="parameters" /> are matched one by one against the corresponding parameter in the method
+///     invocation.
+/// </remarks>
+public readonly struct MethodParameterMatch(string methodName, NamedParameter[] parameters) : IMethodMatch
+{
+	/// <inheritdoc cref="IMethodMatch.Matches(MethodInvocation)" />
+	public bool Matches(MethodInvocation methodInvocation)
+		=> methodInvocation.Name.Equals(methodName) &&
+		   methodInvocation.Parameters.Length == parameters.Length &&
+		   !parameters
+			   .Where((parameter, i) => !parameter.Matches(methodInvocation.Parameters[i]))
+			   .Any();
+
+	/// <inheritdoc cref="object.ToString()" />
+	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..3e7ea48b
--- /dev/null
+++ b/Source/Mockolate/Setup/MethodParametersMatch.cs
@@ -0,0 +1,24 @@
+using Mockolate.Interactions;
+using Mockolate.Internals;
+using Mockolate.Parameters;
+
+namespace Mockolate.Setup;
+
+/// <summary>
+///     Matches a method by name and parameters.
+/// </summary>
+/// <remarks>
+///     During verification, the <paramref name="methodName" /> is compared to the method name of the method invocation,
+///     and the <paramref name="parameters" /> are matched against the parameters in the method invocation.
+/// </remarks>
+public readonly struct MethodParametersMatch(string methodName, IParameters parameters) : IMethodMatch
+{
+	/// <inheritdoc cref="IMethodMatch.Matches(MethodInvocation)" />
+	public bool Matches(MethodInvocation methodInvocation)
+		=> methodInvocation.Name.Equals(methodName) &&
+		   parameters.Matches(methodInvocation.Parameters);
+
+	/// <inheritdoc cref="object.ToString()" />
+	public override string ToString()
+		=> $"{methodName.SubstringAfterLast('.')}({parameters})";
+}
diff --git a/Source/Mockolate/Setup/MethodSetup.cs b/Source/Mockolate/Setup/MethodSetup.cs
index fdd01523..00cf63e4 100644
--- a/Source/Mockolate/Setup/MethodSetup.cs
+++ b/Source/Mockolate/Setup/MethodSetup.cs
@@ -9,7 +9,7 @@ namespace Mockolate.Setup;
 /// <summary>
 ///     Base class for method setups.
 /// </summary>
-public abstract class MethodSetup : IInteractiveMethodSetup
+public abstract class MethodSetup(IMethodMatch methodMatch) : IInteractiveMethodSetup, IVerifiableMethodSetup
 {
 	/// <inheritdoc cref="IInteractiveMethodSetup.HasReturnCalls()" />
 	bool IInteractiveMethodSetup.HasReturnCalls()
@@ -25,7 +25,7 @@ T IInteractiveMethodSetup.SetRefParameter<T>(string parameterName, T value, Mock
 
 	/// <inheritdoc cref="IInteractiveMethodSetup.Matches(MethodInvocation)" />
 	bool IInteractiveMethodSetup.Matches(MethodInvocation methodInvocation)
-		=> IsMatch(methodInvocation);
+		=> methodMatch.Matches(methodInvocation);
 
 	/// <inheritdoc cref="IInteractiveMethodSetup.SkipBaseClass()" />
 	bool? IInteractiveMethodSetup.SkipBaseClass()
@@ -48,6 +48,10 @@ void IInteractiveMethodSetup.Invoke(MethodInvocation methodInvocation, MockBehav
 	public void TriggerCallbacks(object?[] parameters)
 		=> TriggerParameterCallbacks(parameters);
 
+	/// <inheritdoc cref="IVerifiableMethodSetup.GetMatch()" />
+	public IMethodMatch GetMatch()
+		=> methodMatch;
+
 	/// <summary>
 	///     Gets the flag indicating if the base class implementation should be skipped.
 	/// </summary>
@@ -89,11 +93,6 @@ public void TriggerCallbacks(object?[] parameters)
 	protected abstract TResult GetReturnValue<TResult>(MethodInvocation invocation, MockBehavior behavior,
 		Func<TResult> defaultValueGenerator);
 
-	/// <summary>
-	///     Checks if the <paramref name="invocation" /> matches the setup.
-	/// </summary>
-	protected abstract bool IsMatch(MethodInvocation invocation);
-
 	/// <summary>
 	///     Triggers any configured parameter callbacks for the method setup with the specified <paramref name="parameters" />.
 	/// </summary>
diff --git a/Source/Mockolate/Setup/ReturnMethodSetup.cs b/Source/Mockolate/Setup/ReturnMethodSetup.cs
index 0668f668..f16364e2 100644
--- a/Source/Mockolate/Setup/ReturnMethodSetup.cs
+++ b/Source/Mockolate/Setup/ReturnMethodSetup.cs
@@ -9,16 +9,17 @@ namespace Mockolate.Setup;
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public class ReturnMethodSetup<TReturn>(string name) : MethodSetup,
-	IReturnMethodSetupCallbackBuilder<TReturn>, IReturnMethodSetupReturnBuilder<TReturn>
+public class ReturnMethodSetup<TReturn>(string name)
+	: MethodSetup(new MethodParameterMatch(name, [])),
+		IReturnMethodSetupCallbackBuilder<TReturn>, IReturnMethodSetupReturnBuilder<TReturn>
 {
 	private readonly List<Callback<Action<int>>> _callbacks = [];
 	private readonly List<Callback<Func<int, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="IReturnMethodSetup{TReturn}.SkippingBaseClass(bool)" />
 	public IReturnMethodSetup<TReturn> SkippingBaseClass(bool skipBaseClass = true)
@@ -185,10 +186,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		return defaultValueGenerator();
 	}
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(name) && invocation.Parameters.Length == 0;
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	protected override void TriggerParameterCallbacks(object?[] parameters)
 	{
@@ -226,14 +223,15 @@ public class ReturnMethodSetup<TReturn, T1> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Func<int, T1, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1}" />
 	public ReturnMethodSetup(string name, NamedParameter match1)
+		: base(new MethodParameterMatch(name, [match1,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -241,6 +239,7 @@ public ReturnMethodSetup(string name, NamedParameter match1)
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1}" />
 	public ReturnMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -446,12 +445,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		return defaultValueGenerator();
 	}
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(_name) &&
-		   (_matches?.Matches(invocation.Parameters)
-		    ?? Matches([_match1!,], invocation.Parameters));
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	protected override void TriggerParameterCallbacks(object?[] parameters)
 		=> TriggerCallbacks([_match1,], parameters);
@@ -506,14 +499,15 @@ public class ReturnMethodSetup<TReturn, T1, T2> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Func<int, T1, T2, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2}" />
 	public ReturnMethodSetup(string name, NamedParameter match1, NamedParameter match2)
+		: base(new MethodParameterMatch(name, [match1, match2,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -522,6 +516,7 @@ public ReturnMethodSetup(string name, NamedParameter match1, NamedParameter matc
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2}" />
 	public ReturnMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -736,12 +731,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		return defaultValueGenerator();
 	}
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(_name) &&
-		   (_matches?.Matches(invocation.Parameters)
-		    ?? Matches([_match1!, _match2!,], invocation.Parameters));
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	protected override void TriggerParameterCallbacks(object?[] parameters)
 		=> TriggerCallbacks([_match1, _match2,], parameters);
@@ -797,11 +786,11 @@ public class ReturnMethodSetup<TReturn, T1, T2, T3> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Func<int, T1, T2, T3, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2, T3}" />
 	public ReturnMethodSetup(
@@ -809,6 +798,7 @@ public ReturnMethodSetup(
 		NamedParameter match1,
 		NamedParameter match2,
 		NamedParameter match3)
+		: base(new MethodParameterMatch(name, [match1, match2, match3,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -818,6 +808,7 @@ public ReturnMethodSetup(
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2, T3}" />
 	public ReturnMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -1041,12 +1032,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		return defaultValueGenerator();
 	}
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(_name) &&
-		   (_matches?.Matches(invocation.Parameters)
-		    ?? Matches([_match1!, _match2!, _match3!,], invocation.Parameters));
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	protected override void TriggerParameterCallbacks(object?[] parameters)
 		=> TriggerCallbacks([_match1, _match2, _match3,], parameters);
@@ -1104,11 +1089,11 @@ public class ReturnMethodSetup<TReturn, T1, T2, T3, T4> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Func<int, T1, T2, T3, T4, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2, T3, T4}" />
 	public ReturnMethodSetup(
@@ -1117,6 +1102,7 @@ public ReturnMethodSetup(
 		NamedParameter match2,
 		NamedParameter match3,
 		NamedParameter match4)
+		: base(new MethodParameterMatch(name, [match1, match2, match3, match4,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -1127,6 +1113,7 @@ public ReturnMethodSetup(
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2, T3, T4}" />
 	public ReturnMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -1364,12 +1351,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		return defaultValueGenerator();
 	}
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(_name) &&
-		   (_matches?.Matches(invocation.Parameters)
-		    ?? Matches([_match1!, _match2!, _match3!, _match4!,], invocation.Parameters));
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	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 2ebaddb7..ca994646 100644
--- a/Source/Mockolate/Setup/VoidMethodSetup.cs
+++ b/Source/Mockolate/Setup/VoidMethodSetup.cs
@@ -9,15 +9,17 @@ namespace Mockolate.Setup;
 /// <summary>
 ///     Sets up a method returning <see langword="void" />.
 /// </summary>
-public class VoidMethodSetup(string name) : MethodSetup, IVoidMethodSetupCallbackBuilder, IVoidMethodSetupReturnBuilder
+public class VoidMethodSetup(string name)
+	: MethodSetup(new MethodParameterMatch(name, [])),
+		IVoidMethodSetupCallbackBuilder, IVoidMethodSetupReturnBuilder
 {
 	private readonly List<Callback<Action<int>>> _callbacks = [];
 	private readonly List<Callback<Action<int>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="IVoidMethodSetup.SkippingBaseClass(bool)" />
 	public IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true)
@@ -165,10 +167,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		where TResult : default
 		=> throw new MockException("The method setup does not support return values.");
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(name) && invocation.Parameters.Length == 0;
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	protected override void TriggerParameterCallbacks(object?[] parameters)
 	{
@@ -202,14 +200,15 @@ public class VoidMethodSetup<T1> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Action<int, T1>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="VoidMethodSetup{T1}" />
 	public VoidMethodSetup(string name, NamedParameter match1)
+		: base(new MethodParameterMatch(name, [match1,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -217,6 +216,7 @@ public VoidMethodSetup(string name, NamedParameter match1)
 
 	/// <inheritdoc cref="VoidMethodSetup{T1}" />
 	public VoidMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -388,12 +388,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		where TResult : default
 		=> throw new MockException("The method setup does not support return values.");
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(_name) &&
-		   (_matches?.Matches(invocation.Parameters)
-		    ?? Matches([_match1!,], invocation.Parameters));
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	protected override void TriggerParameterCallbacks(object?[] parameters)
 		=> TriggerCallbacks([_match1,], parameters);
@@ -444,14 +438,15 @@ public class VoidMethodSetup<T1, T2> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Action<int, T1, T2>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="VoidMethodSetup{T1, T2}" />
 	public VoidMethodSetup(string name, NamedParameter match1, NamedParameter match2)
+		: base(new MethodParameterMatch(name, [match1, match2,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -460,6 +455,7 @@ public VoidMethodSetup(string name, NamedParameter match1, NamedParameter match2
 
 	/// <inheritdoc cref="VoidMethodSetup{T1, T2}" />
 	public VoidMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -632,12 +628,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		where TResult : default
 		=> throw new MockException("The method setup does not support return values.");
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(_name) &&
-		   (_matches?.Matches(invocation.Parameters)
-		    ?? Matches([_match1!, _match2!,], invocation.Parameters));
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	protected override void TriggerParameterCallbacks(object?[] parameters)
 		=> TriggerCallbacks([_match1, _match2,], parameters);
@@ -689,11 +679,11 @@ public class VoidMethodSetup<T1, T2, T3> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Action<int, T1, T2, T3>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="VoidMethodSetup{T1, T2, T3}" />
 	public VoidMethodSetup(
@@ -701,6 +691,7 @@ public VoidMethodSetup(
 		NamedParameter match1,
 		NamedParameter match2,
 		NamedParameter match3)
+		: base(new MethodParameterMatch(name, [match1, match2, match3,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -710,6 +701,7 @@ public VoidMethodSetup(
 
 	/// <inheritdoc cref="VoidMethodSetup{T1, T2, T3}" />
 	public VoidMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -885,12 +877,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		where TResult : default
 		=> throw new MockException("The method setup does not support return values.");
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(_name) &&
-		   (_matches?.Matches(invocation.Parameters)
-		    ?? Matches([_match1!, _match2!, _match3!,], invocation.Parameters));
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	protected override void TriggerParameterCallbacks(object?[] parameters)
 		=> TriggerCallbacks([_match1, _match2, _match3,], parameters);
@@ -943,11 +929,11 @@ public class VoidMethodSetup<T1, T2, T3, T4> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Action<int, T1, T2, T3, T4>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="VoidMethodSetup{T1, T2, T3, T4}" />
 	public VoidMethodSetup(
@@ -956,6 +942,7 @@ public VoidMethodSetup(
 		NamedParameter match2,
 		NamedParameter match3,
 		NamedParameter match4)
+		: base(new MethodParameterMatch(name, [match1, match2, match3, match4,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -966,6 +953,7 @@ public VoidMethodSetup(
 
 	/// <inheritdoc cref="VoidMethodSetup{T1, T2, T3, T4}" />
 	public VoidMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -1144,12 +1132,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 		where TResult : default
 		=> throw new MockException("The method setup does not support return values.");
 
-	/// <inheritdoc cref="MethodSetup.IsMatch(MethodInvocation)" />
-	protected override bool IsMatch(MethodInvocation invocation)
-		=> invocation.Name.Equals(_name) &&
-		   (_matches?.Matches(invocation.Parameters)
-		    ?? Matches([_match1!, _match2!, _match3!, _match4!,], invocation.Parameters));
-
 	/// <inheritdoc cref="MethodSetup.TriggerParameterCallbacks(object?[])" />
 	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 a7140d37..7edfbf5d 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<T>(this Mockolate.Setup.IMockSetup<T> mock)
             where T :  class { }
+        public static Mockolate.Verify.VerificationResult<T> InvokedSetup<T>(this Mockolate.Verify.IMockVerify<T> verify, Mockolate.Setup.IMethodSetup setup) { }
     }
     [System.Diagnostics.DebuggerDisplay("{ToString()}")]
     public class MockRegistration
@@ -131,8 +132,7 @@ namespace Mockolate
         public Mockolate.Verify.VerificationResult<T> Indexer<T>(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<TResult> InvokeMethod<TResult>(string methodName, System.Func<object?[], TResult> defaultValue, params Mockolate.Parameters.NamedParameterValue[] parameters) { }
-        public Mockolate.Verify.VerificationResult<T> Method<T>(T subject, string methodName, Mockolate.Parameters.IParameters parameters) { }
-        public Mockolate.Verify.VerificationResult<T> Method<T>(T subject, string methodName, params Mockolate.Parameters.NamedParameter[] parameters) { }
+        public Mockolate.Verify.VerificationResult<T> Method<T>(T subject, Mockolate.Setup.IMethodMatch methodMatch) { }
         public Mockolate.Verify.VerificationResult<T> Property<T>(T subject, string propertyName) { }
         public Mockolate.Verify.VerificationResult<T> Property<T>(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<out T> : Mockolate.IInteractiveMock<T>, Mockolate.Setup.IMockMethodSetupWithEquals<T>, Mockolate.Setup.IMockMethodSetupWithGetHashCode<T>, Mockolate.Setup.IMockMethodSetup<T> { }
     public interface IMockMethodSetupWithEquals<out T> : Mockolate.IInteractiveMock<T>, Mockolate.Setup.IMockMethodSetup<T>
     {
@@ -952,102 +957,102 @@ namespace Mockolate.Setup
     public interface IProtectedMockMethodSetup<out T> : Mockolate.IInteractiveMock<T> { }
     public interface IProtectedMockPropertySetup<out T> : Mockolate.IInteractiveMock<T> { }
     public interface IProtectedMockSetup<out T> : Mockolate.IInteractiveMock<T> { }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4> Only(int times);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4> Only(int times);
     }
-    public interface IReturnMethodSetup<in TReturn>
+    public interface IReturnMethodSetup<in TReturn> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> Do(System.Action<int> callback);
@@ -1059,7 +1064,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1>
+    public interface IReturnMethodSetup<in TReturn, out T1> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1> Do(System.Action<T1> callback);
@@ -1074,7 +1079,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1, out T2>
+    public interface IReturnMethodSetup<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2> Do(System.Action<T1, T2> callback);
@@ -1089,7 +1094,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3>
+    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3> Do(System.Action<T1, T2, T3> callback);
@@ -1104,7 +1109,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4>
+    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4> Do(System.Action<T1, T2, T3, T4> callback);
@@ -1120,7 +1125,11 @@ namespace Mockolate.Setup
             where TException : System.Exception, new ();
     }
     public interface ISetup { }
-    public interface IVoidMethodSetup
+    public interface IVerifiableMethodSetup
+    {
+        Mockolate.Setup.IMethodMatch GetMatch();
+    }
+    public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action<int> callback);
@@ -1131,102 +1140,102 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws<TException>()
             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<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupCallbackBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4> When(System.Func<int, bool> 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<out T1> : Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1> Only(int times);
     }
-    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2> Only(int times);
     }
-    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3> Only(int times);
     }
-    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4> 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<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupReturnBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupReturnBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4> When(System.Func<int, bool> 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<out T1> : Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1> Only(int times);
     }
-    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2> Only(int times);
     }
-    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3> Only(int times);
     }
-    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4> Only(int times);
     }
-    public interface IVoidMethodSetup<out T1>
+    public interface IVoidMethodSetup<out T1> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1> Do(System.Action<T1> callback);
@@ -1239,7 +1248,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IVoidMethodSetup<out T1, out T2>
+    public interface IVoidMethodSetup<out T1, out T2> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2> Do(System.Action<T1, T2> callback);
@@ -1252,7 +1261,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IVoidMethodSetup<out T1, out T2, out T3>
+    public interface IVoidMethodSetup<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3> Do(System.Action<T1, T2, T3> callback);
@@ -1265,7 +1274,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IVoidMethodSetup<out T1, out T2, out T3, out T4>
+    public interface IVoidMethodSetup<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4> Do(System.Action<T1, T2, T3, T4> callback);
@@ -1396,14 +1405,26 @@ namespace Mockolate.Setup
         public Mockolate.Setup.IIndexerSetupReturnBuilder<TValue, T1, T2, T3, T4> Throws<TException>()
             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 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 methodInvocation) { }
+        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<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator);
         protected abstract bool? GetSkipBaseClass();
         protected virtual bool HasReturnCalls() { }
-        protected abstract bool IsMatch(Mockolate.Interactions.MethodInvocation invocation);
         protected abstract T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator);
         protected abstract T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior);
         public void TriggerCallbacks(object?[] parameters) { }
@@ -1470,7 +1491,7 @@ namespace Mockolate.Setup
         public static System.ReadOnlySpan<T> op_Implicit(Mockolate.Setup.ReadOnlySpanWrapper<T> wrapper) { }
         public static Mockolate.Setup.ReadOnlySpanWrapper<T> op_Implicit(System.ReadOnlySpan<T> span) { }
     }
-    public class ReturnMethodSetup<TReturn> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public class ReturnMethodSetup<TReturn> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         public ReturnMethodSetup(string name) { }
         public Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> Do(System.Action callback) { }
@@ -1479,7 +1500,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn> Returns(TReturn returnValue) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
@@ -1492,7 +1512,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public class ReturnMethodSetup<TReturn, T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { }
@@ -1503,7 +1523,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Returns(System.Func<T1, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Returns(TReturn returnValue) { }
@@ -1518,7 +1537,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public class ReturnMethodSetup<TReturn, T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { }
@@ -1529,7 +1548,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Returns(System.Func<T1, T2, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Returns(TReturn returnValue) { }
@@ -1544,7 +1562,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public class ReturnMethodSetup<TReturn, T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { }
@@ -1555,7 +1573,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Returns(System.Func<T1, T2, T3, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Returns(TReturn returnValue) { }
@@ -1570,7 +1587,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public class ReturnMethodSetup<TReturn, T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         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) { }
@@ -1581,7 +1598,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4> Returns(System.Func<T1, T2, T3, T4, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4> Returns(TReturn returnValue) { }
@@ -1603,7 +1619,7 @@ namespace Mockolate.Setup
         public static System.Span<T> op_Implicit(Mockolate.Setup.SpanWrapper<T> wrapper) { }
         public static Mockolate.Setup.SpanWrapper<T> op_Implicit(System.Span<T> 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) { }
@@ -1612,7 +1628,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1623,7 +1638,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
+    public class VoidMethodSetup<T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { }
@@ -1634,7 +1649,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1> SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1646,7 +1660,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public class VoidMethodSetup<T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { }
@@ -1657,7 +1671,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1, T2> SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1669,7 +1682,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public class VoidMethodSetup<T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { }
@@ -1680,7 +1693,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1, T2, T3> SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1692,7 +1704,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public class VoidMethodSetup<T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         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) { }
@@ -1703,7 +1715,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4> 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 864ccb26..8199b859 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<T>(this Mockolate.Setup.IMockSetup<T> mock)
             where T :  class { }
+        public static Mockolate.Verify.VerificationResult<T> InvokedSetup<T>(this Mockolate.Verify.IMockVerify<T> verify, Mockolate.Setup.IMethodSetup setup) { }
     }
     [System.Diagnostics.DebuggerDisplay("{ToString()}")]
     public class MockRegistration
@@ -130,8 +131,7 @@ namespace Mockolate
         public Mockolate.Verify.VerificationResult<T> Indexer<T>(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<TResult> InvokeMethod<TResult>(string methodName, System.Func<object?[], TResult> defaultValue, params Mockolate.Parameters.NamedParameterValue[] parameters) { }
-        public Mockolate.Verify.VerificationResult<T> Method<T>(T subject, string methodName, Mockolate.Parameters.IParameters parameters) { }
-        public Mockolate.Verify.VerificationResult<T> Method<T>(T subject, string methodName, params Mockolate.Parameters.NamedParameter[] parameters) { }
+        public Mockolate.Verify.VerificationResult<T> Method<T>(T subject, Mockolate.Setup.IMethodMatch methodMatch) { }
         public Mockolate.Verify.VerificationResult<T> Property<T>(T subject, string propertyName) { }
         public Mockolate.Verify.VerificationResult<T> Property<T>(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<out T> : Mockolate.IInteractiveMock<T>, Mockolate.Setup.IMockMethodSetupWithEquals<T>, Mockolate.Setup.IMockMethodSetupWithGetHashCode<T>, Mockolate.Setup.IMockMethodSetup<T> { }
     public interface IMockMethodSetupWithEquals<out T> : Mockolate.IInteractiveMock<T>, Mockolate.Setup.IMockMethodSetup<T>
     {
@@ -951,102 +956,102 @@ namespace Mockolate.Setup
     public interface IProtectedMockMethodSetup<out T> : Mockolate.IInteractiveMock<T> { }
     public interface IProtectedMockPropertySetup<out T> : Mockolate.IInteractiveMock<T> { }
     public interface IProtectedMockSetup<out T> : Mockolate.IInteractiveMock<T> { }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4> Only(int times);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4> Only(int times);
     }
-    public interface IReturnMethodSetup<in TReturn>
+    public interface IReturnMethodSetup<in TReturn> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> Do(System.Action<int> callback);
@@ -1058,7 +1063,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1>
+    public interface IReturnMethodSetup<in TReturn, out T1> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1> Do(System.Action<T1> callback);
@@ -1073,7 +1078,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1, out T2>
+    public interface IReturnMethodSetup<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2> Do(System.Action<T1, T2> callback);
@@ -1088,7 +1093,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3>
+    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3> Do(System.Action<T1, T2, T3> callback);
@@ -1103,7 +1108,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4>
+    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4> Do(System.Action<T1, T2, T3, T4> callback);
@@ -1119,7 +1124,11 @@ namespace Mockolate.Setup
             where TException : System.Exception, new ();
     }
     public interface ISetup { }
-    public interface IVoidMethodSetup
+    public interface IVerifiableMethodSetup
+    {
+        Mockolate.Setup.IMethodMatch GetMatch();
+    }
+    public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action<int> callback);
@@ -1130,102 +1139,102 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws<TException>()
             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<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupCallbackBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4> When(System.Func<int, bool> 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<out T1> : Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1> Only(int times);
     }
-    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2> Only(int times);
     }
-    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3> Only(int times);
     }
-    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4> 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<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupReturnBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupReturnBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4> When(System.Func<int, bool> 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<out T1> : Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1> Only(int times);
     }
-    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2> Only(int times);
     }
-    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3> Only(int times);
     }
-    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4> Only(int times);
     }
-    public interface IVoidMethodSetup<out T1>
+    public interface IVoidMethodSetup<out T1> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1> Do(System.Action<T1> callback);
@@ -1238,7 +1247,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IVoidMethodSetup<out T1, out T2>
+    public interface IVoidMethodSetup<out T1, out T2> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2> Do(System.Action<T1, T2> callback);
@@ -1251,7 +1260,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IVoidMethodSetup<out T1, out T2, out T3>
+    public interface IVoidMethodSetup<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3> Do(System.Action<T1, T2, T3> callback);
@@ -1264,7 +1273,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IVoidMethodSetup<out T1, out T2, out T3, out T4>
+    public interface IVoidMethodSetup<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4> Do(System.Action<T1, T2, T3, T4> callback);
@@ -1395,14 +1404,26 @@ namespace Mockolate.Setup
         public Mockolate.Setup.IIndexerSetupReturnBuilder<TValue, T1, T2, T3, T4> Throws<TException>()
             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 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 methodInvocation) { }
+        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<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator);
         protected abstract bool? GetSkipBaseClass();
         protected virtual bool HasReturnCalls() { }
-        protected abstract bool IsMatch(Mockolate.Interactions.MethodInvocation invocation);
         protected abstract T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator);
         protected abstract T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior);
         public void TriggerCallbacks(object?[] parameters) { }
@@ -1469,7 +1490,7 @@ namespace Mockolate.Setup
         public static System.ReadOnlySpan<T> op_Implicit(Mockolate.Setup.ReadOnlySpanWrapper<T> wrapper) { }
         public static Mockolate.Setup.ReadOnlySpanWrapper<T> op_Implicit(System.ReadOnlySpan<T> span) { }
     }
-    public class ReturnMethodSetup<TReturn> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public class ReturnMethodSetup<TReturn> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         public ReturnMethodSetup(string name) { }
         public Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> Do(System.Action callback) { }
@@ -1478,7 +1499,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn> Returns(TReturn returnValue) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
@@ -1491,7 +1511,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public class ReturnMethodSetup<TReturn, T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { }
@@ -1502,7 +1522,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Returns(System.Func<T1, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Returns(TReturn returnValue) { }
@@ -1517,7 +1536,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public class ReturnMethodSetup<TReturn, T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { }
@@ -1528,7 +1547,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Returns(System.Func<T1, T2, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Returns(TReturn returnValue) { }
@@ -1543,7 +1561,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public class ReturnMethodSetup<TReturn, T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { }
@@ -1554,7 +1572,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Returns(System.Func<T1, T2, T3, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Returns(TReturn returnValue) { }
@@ -1569,7 +1586,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public class ReturnMethodSetup<TReturn, T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         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) { }
@@ -1580,7 +1597,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4> Returns(System.Func<T1, T2, T3, T4, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4> Returns(TReturn returnValue) { }
@@ -1602,7 +1618,7 @@ namespace Mockolate.Setup
         public static System.Span<T> op_Implicit(Mockolate.Setup.SpanWrapper<T> wrapper) { }
         public static Mockolate.Setup.SpanWrapper<T> op_Implicit(System.Span<T> 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) { }
@@ -1611,7 +1627,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1622,7 +1637,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
+    public class VoidMethodSetup<T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { }
@@ -1633,7 +1648,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1> SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1645,7 +1659,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public class VoidMethodSetup<T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { }
@@ -1656,7 +1670,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1, T2> SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1668,7 +1681,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public class VoidMethodSetup<T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { }
@@ -1679,7 +1692,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1, T2, T3> SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1691,7 +1703,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public class VoidMethodSetup<T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         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) { }
@@ -1702,7 +1714,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4> 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 f946ed4f..715d3b1c 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<T>(this Mockolate.Setup.IMockSetup<T> mock)
             where T :  class { }
+        public static Mockolate.Verify.VerificationResult<T> InvokedSetup<T>(this Mockolate.Verify.IMockVerify<T> verify, Mockolate.Setup.IMethodSetup setup) { }
     }
     [System.Diagnostics.DebuggerDisplay("{ToString()}")]
     public class MockRegistration
@@ -125,8 +126,7 @@ namespace Mockolate
         public Mockolate.Verify.VerificationResult<T> Indexer<T>(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<TResult> InvokeMethod<TResult>(string methodName, System.Func<object?[], TResult> defaultValue, params Mockolate.Parameters.NamedParameterValue[] parameters) { }
-        public Mockolate.Verify.VerificationResult<T> Method<T>(T subject, string methodName, Mockolate.Parameters.IParameters parameters) { }
-        public Mockolate.Verify.VerificationResult<T> Method<T>(T subject, string methodName, params Mockolate.Parameters.NamedParameter[] parameters) { }
+        public Mockolate.Verify.VerificationResult<T> Method<T>(T subject, Mockolate.Setup.IMethodMatch methodMatch) { }
         public Mockolate.Verify.VerificationResult<T> Property<T>(T subject, string propertyName) { }
         public Mockolate.Verify.VerificationResult<T> Property<T>(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<out T> : Mockolate.IInteractiveMock<T>, Mockolate.Setup.IMockMethodSetupWithEquals<T>, Mockolate.Setup.IMockMethodSetupWithGetHashCode<T>, Mockolate.Setup.IMockMethodSetup<T> { }
     public interface IMockMethodSetupWithEquals<out T> : Mockolate.IInteractiveMock<T>, Mockolate.Setup.IMockMethodSetup<T>
     {
@@ -914,102 +919,102 @@ namespace Mockolate.Setup
     public interface IProtectedMockMethodSetup<out T> : Mockolate.IInteractiveMock<T> { }
     public interface IProtectedMockPropertySetup<out T> : Mockolate.IInteractiveMock<T> { }
     public interface IProtectedMockSetup<out T> : Mockolate.IInteractiveMock<T> { }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupCallbackBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4> InParallel();
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3> Only(int times);
     }
-    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupCallbackWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4> Only(int times);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupReturnBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4> When(System.Func<int, bool> predicate);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn> : Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3> Only(int times);
     }
-    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4> Only(int times);
     }
-    public interface IReturnMethodSetup<in TReturn>
+    public interface IReturnMethodSetup<in TReturn> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> Do(System.Action<int> callback);
@@ -1021,7 +1026,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1>
+    public interface IReturnMethodSetup<in TReturn, out T1> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1> Do(System.Action<T1> callback);
@@ -1036,7 +1041,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1, out T2>
+    public interface IReturnMethodSetup<in TReturn, out T1, out T2> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2> Do(System.Action<T1, T2> callback);
@@ -1051,7 +1056,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3>
+    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3> Do(System.Action<T1, T2, T3> callback);
@@ -1066,7 +1071,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4>
+    public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4> Do(System.Action callback);
         Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4> Do(System.Action<T1, T2, T3, T4> callback);
@@ -1082,7 +1087,11 @@ namespace Mockolate.Setup
             where TException : System.Exception, new ();
     }
     public interface ISetup { }
-    public interface IVoidMethodSetup
+    public interface IVerifiableMethodSetup
+    {
+        Mockolate.Setup.IMethodMatch GetMatch();
+    }
+    public interface IVoidMethodSetup : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder Do(System.Action<int> callback);
@@ -1093,102 +1102,102 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder Throws<TException>()
             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<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupCallbackBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupCallbackBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4> InParallel();
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4> When(System.Func<int, bool> 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<out T1> : Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1> Only(int times);
     }
-    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2> Only(int times);
     }
-    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3> Only(int times);
     }
-    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupCallbackWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4> 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<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupReturnBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupReturnBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3> When(System.Func<int, bool> predicate);
     }
-    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupReturnBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4> When(System.Func<int, bool> 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<out T1> : Mockolate.Setup.IVoidMethodSetup<T1>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1> Only(int times);
     }
-    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2> : Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2> Only(int times);
     }
-    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3> Only(int times);
     }
-    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public interface IVoidMethodSetupReturnWhenBuilder<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4> For(int times);
         Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4> Only(int times);
     }
-    public interface IVoidMethodSetup<out T1>
+    public interface IVoidMethodSetup<out T1> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1> Do(System.Action<T1> callback);
@@ -1201,7 +1210,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IVoidMethodSetup<out T1, out T2>
+    public interface IVoidMethodSetup<out T1, out T2> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2> Do(System.Action<T1, T2> callback);
@@ -1214,7 +1223,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IVoidMethodSetup<out T1, out T2, out T3>
+    public interface IVoidMethodSetup<out T1, out T2, out T3> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3> Do(System.Action<T1, T2, T3> callback);
@@ -1227,7 +1236,7 @@ namespace Mockolate.Setup
         Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3> Throws<TException>()
             where TException : System.Exception, new ();
     }
-    public interface IVoidMethodSetup<out T1, out T2, out T3, out T4>
+    public interface IVoidMethodSetup<out T1, out T2, out T3, out T4> : Mockolate.Setup.IMethodSetup
     {
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4> Do(System.Action callback);
         Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4> Do(System.Action<T1, T2, T3, T4> callback);
@@ -1358,14 +1367,26 @@ namespace Mockolate.Setup
         public Mockolate.Setup.IIndexerSetupReturnBuilder<TValue, T1, T2, T3, T4> Throws<TException>()
             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 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 methodInvocation) { }
+        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<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator);
         protected abstract bool? GetSkipBaseClass();
         protected virtual bool HasReturnCalls() { }
-        protected abstract bool IsMatch(Mockolate.Interactions.MethodInvocation invocation);
         protected abstract T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator);
         protected abstract T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior);
         public void TriggerCallbacks(object?[] parameters) { }
@@ -1425,7 +1446,7 @@ namespace Mockolate.Setup
             where TException : System.Exception, new () { }
         public override string ToString() { }
     }
-    public class ReturnMethodSetup<TReturn> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
+    public class ReturnMethodSetup<TReturn> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn>, Mockolate.Setup.IReturnMethodSetup<TReturn>
     {
         public ReturnMethodSetup(string name) { }
         public Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn> Do(System.Action callback) { }
@@ -1434,7 +1455,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn> Returns(TReturn returnValue) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
@@ -1447,7 +1467,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
+    public class ReturnMethodSetup<TReturn, T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1>
     {
         public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { }
@@ -1458,7 +1478,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Returns(System.Func<T1, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1> Returns(TReturn returnValue) { }
@@ -1473,7 +1492,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
+    public class ReturnMethodSetup<TReturn, T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2>
     {
         public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { }
@@ -1484,7 +1503,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Returns(System.Func<T1, T2, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2> Returns(TReturn returnValue) { }
@@ -1499,7 +1517,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
+    public class ReturnMethodSetup<TReturn, T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3>
     {
         public ReturnMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public ReturnMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { }
@@ -1510,7 +1528,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Returns(System.Func<T1, T2, T3, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3> Returns(TReturn returnValue) { }
@@ -1525,7 +1542,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class ReturnMethodSetup<TReturn, T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
+    public class ReturnMethodSetup<TReturn, T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IReturnMethodSetupCallbackBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupCallbackWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder<TReturn, T1, T2, T3, T4>, Mockolate.Setup.IReturnMethodSetup<TReturn, T1, T2, T3, T4>
     {
         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) { }
@@ -1536,7 +1553,6 @@ namespace Mockolate.Setup
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
         protected override bool HasReturnCalls() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4> Returns(System.Func<TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4> Returns(System.Func<T1, T2, T3, T4, TReturn> callback) { }
         public Mockolate.Setup.IReturnMethodSetupReturnBuilder<TReturn, T1, T2, T3, T4> Returns(TReturn returnValue) { }
@@ -1551,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) { }
@@ -1560,7 +1576,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1571,7 +1586,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
+    public class VoidMethodSetup<T1> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1>, Mockolate.Setup.IVoidMethodSetup<T1>
     {
         public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1) { }
@@ -1582,7 +1597,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1> SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1594,7 +1608,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
+    public class VoidMethodSetup<T1, T2> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2>, Mockolate.Setup.IVoidMethodSetup<T1, T2>
     {
         public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2) { }
@@ -1605,7 +1619,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1, T2> SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1617,7 +1630,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
+    public class VoidMethodSetup<T1, T2, T3> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3>
     {
         public VoidMethodSetup(string name, Mockolate.Parameters.IParameters matches) { }
         public VoidMethodSetup(string name, Mockolate.Parameters.NamedParameter match1, Mockolate.Parameters.NamedParameter match2, Mockolate.Parameters.NamedParameter match3) { }
@@ -1628,7 +1641,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1, T2, T3> SkippingBaseClass(bool skipBaseClass = true) { }
@@ -1640,7 +1652,7 @@ namespace Mockolate.Setup
         public override string ToString() { }
         protected override void TriggerParameterCallbacks(object?[] parameters) { }
     }
-    public class VoidMethodSetup<T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
+    public class VoidMethodSetup<T1, T2, T3, T4> : Mockolate.Setup.MethodSetup, Mockolate.Setup.IMethodSetup, Mockolate.Setup.IVoidMethodSetupCallbackBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupCallbackWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetupReturnWhenBuilder<T1, T2, T3, T4>, Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4>
     {
         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) { }
@@ -1651,7 +1663,6 @@ namespace Mockolate.Setup
         protected override void ExecuteCallback(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior) { }
         protected override TResult GetReturnValue<TResult>(Mockolate.Interactions.MethodInvocation invocation, Mockolate.MockBehavior behavior, System.Func<TResult> defaultValueGenerator) { }
         protected override bool? GetSkipBaseClass() { }
-        protected override bool IsMatch(Mockolate.Interactions.MethodInvocation invocation) { }
         protected override T SetOutParameter<T>(string parameterName, System.Func<T> defaultValueGenerator) { }
         protected override T SetRefParameter<T>(string parameterName, T value, Mockolate.MockBehavior behavior) { }
         public Mockolate.Setup.IVoidMethodSetup<T1, T2, T3, T4> SkippingBaseClass(bool skipBaseClass = true) { }
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<MyServiceBase>();
+			IMethodSetup setup = new MyMethodSetup();
+
+			void Act()
+			{
+				mock.VerifyMock.InvokedSetup(setup).Never();
+			}
+
+			await That(Act).Throws<MockException>()
+				.WithMessage("The setup is not verifiable.");
+		}
+
+		[Fact]
+		public async Task WhenSubjectIsNoMock_ShouldThrowMockException()
+		{
+			MyServiceBase mock = Mock.Create<MyServiceBase>();
+			IMockVerify<MyServiceBase> verify = new MyMockVerify<MyServiceBase>();
+			IMethodSetup setup = mock.SetupMock.Method.DoSomething(Match.AnyParameters());
+
+			void Act()
+			{
+				verify.InvokedSetup(setup).Never();
+			}
+
+			await That(Act).Throws<MockException>()
+				.WithMessage("The subject is no mock subject.");
+		}
+
+		private sealed class MyMockVerify<T> : IMockVerify<T>
+		{
+			public bool ThatAllInteractionsAreVerified()
+				=> throw new NotSupportedException();
+
+			public bool ThatAllSetupsAreUsed()
+				=> throw new NotSupportedException();
+		}
+
+		private sealed class MyMethodSetup : IMethodSetup
+		{
+		}
+	}
+}
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<IChocolateDispenser> result =
-			registration.Method(mock, "foo.bar", new NamedParameter("p1", (IParameter)It.IsAny<int>()));
+			registration.Method(mock,
+				new MethodParameterMatch("foo.bar", [new NamedParameter("p1", (IParameter)It.IsAny<int>()),]));
 
 		await That(result).Once();
 	}
@@ -28,7 +30,8 @@ public async Task Method_WhenOnlyNameMatches_ShouldReturnNever()
 		registration.InvokeMethod("foo.bar", new NamedParameterValue("p1", 4));
 
 		VerificationResult<IChocolateDispenser> result =
-			registration.Method(mock, "foo.bar", new NamedParameter("p1", (IParameter)It.IsAny<string>()));
+			registration.Method(mock,
+				new MethodParameterMatch("foo.bar", [new NamedParameter("p1", (IParameter)It.IsAny<string>()),]));
 
 		await That(result).Never();
 	}
@@ -41,7 +44,8 @@ public async Task Method_WhenOnlyValueMatches_ShouldReturnNever()
 		registration.InvokeMethod("foo.bar", new NamedParameterValue("p1", 4));
 
 		VerificationResult<IChocolateDispenser> result =
-			registration.Method(mock, "baz.bar", new NamedParameter("p1", (IParameter)It.IsAny<int>()));
+			registration.Method(mock,
+				new MethodParameterMatch("baz.bar", [new NamedParameter("p1", (IParameter)It.IsAny<int>()),]));
 
 		await That(result).Never();
 	}
@@ -53,7 +57,8 @@ public async Task Method_WithoutInteractions_ShouldReturnNeverResult()
 		MockRegistration registration = ((IHasMockRegistration)mock).Registrations;
 
 		VerificationResult<IChocolateDispenser> result =
-			registration.Method(mock, "foo.bar", new NamedParameter("p1", (IParameter)It.IsAny<int>()));
+			registration.Method(mock,
+				new MethodParameterMatch("foo.bar", [new NamedParameter("p1", (IParameter)It.IsAny<int>()),]));
 
 		await That(result).Never();
 		await That(((IVerificationResult)result).Expectation).IsEqualTo("invoked method bar(It.IsAny<int>())");
diff --git a/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs b/Tests/Mockolate.Tests/MockMethods/SetupMethodTests.cs
index d82dfc26..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<IReturnMethodSetupTest>();
+			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<IReturnMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method1(It.Satisfies<int>(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<IReturnMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method2(
+				It.Satisfies<int>(x => x > 0), It.IsAny<int>());
+
+			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<IReturnMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method3(
+				It.Satisfies<int>(x => x > 0), It.IsAny<int>(), It.IsAny<int>());
+
+			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<IReturnMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method4(
+				It.Satisfies<int>(x => x > 0), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>());
+
+			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<IReturnMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method5(
+				It.Satisfies<int>(x => x > 0), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>());
+
+			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<IVoidMethodSetupTest>();
+			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<IVoidMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method1(It.Satisfies<int>(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<IVoidMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method2(
+				It.Satisfies<int>(x => x > 0), It.IsAny<int>());
+
+			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<IVoidMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method3(
+				It.Satisfies<int>(x => x > 0), It.IsAny<int>(), It.IsAny<int>());
+
+			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<IVoidMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method4(
+				It.Satisfies<int>(x => x > 0), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>());
+
+			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<IVoidMethodSetupTest>();
+			IMethodSetup setup = mock.SetupMock.Method.Method5(
+				It.Satisfies<int>(x => x > 0), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>());
+
+			mock.Method5(firstParameter, 2, 3, 4, 5);
+
+			await That(mock.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount);
+		}
+
 		[Fact]
 		public async Task ToString_AnyParameters_ShouldReturnMethodSignature()
 		{
@@ -1140,7 +1300,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);
@@ -1172,9 +1332,6 @@ protected override TResult GetReturnValue<TResult>(MethodInvocation invocation,
 			Func<TResult> defaultValueGenerator)
 			=> throw new NotSupportedException();
 
-		protected override bool IsMatch(MethodInvocation invocation)
-			=> throw new NotSupportedException();
-
 		protected override void TriggerParameterCallbacks(object?[] parameters)
 			=> throw new NotSupportedException();
 	}
diff --git a/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs b/Tests/Mockolate.Tests/MockMethods/VerifyInvokedTests.cs
index 864cd50f..c2f766a9 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_ShouldVerifySameConditionAsSetup(int firstParameter, int expectedCallCount)
+	{
+		MockTests.IMyService sut = Mock.Create<MockTests.IMyService>();
+		IMethodSetup setup = sut.SetupMock.Method.Subtract(
+			It.Satisfies<int>(x => x > 0),
+			It.IsAny<int?>()).Returns(1);
+
+		sut.Subtract(firstParameter, 4);
+
+		await That(sut.VerifyMock.InvokedSetup(setup)).Exactly(expectedCallCount);
+	}
+
 	[Fact]
 	public async Task MethodWithDifferentName_ShouldNotMatch()
 	{