How to use matchableInvocation method of MethodTemplate class

...122    let body = !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """123    return \(ObjectInitializationTemplate(124              name: "Mockingbird.Mockable",125              genericTypes: genericTypes,126              arguments: [("mock", mockObject), ("invocation", matchableInvocation())]))127    """128    methods.append(129      FunctionDefinitionTemplate(attributes: method.attributes.safeDeclarations,130                                 declaration: declaration,131                                 genericConstraints: genericConstraints,132                                 body: body).render())133    134    // Variadics generate both the array and variadic-forms of the function signature to allow use135    // of either when stubbing and verifying.136    if method.isVariadic {137      let body = !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """138      return \(ObjectInitializationTemplate(139                name: "Mockingbird.Mockable",140                genericTypes: genericTypes,141                arguments: [("mock", mockObject),142                            ("invocation", matchableInvocation(isVariadic: true))]))143      """144      let declaration = "public \(regularModifiers)func \(fullNameForMatchingVariadics) -> \(returnType)"145      methods.append(146        FunctionDefinitionTemplate(attributes: method.attributes.safeDeclarations,147                                   declaration: declaration,148                                   genericConstraints: genericConstraints,149                                   body: body).render())150    }151    152    return String(lines: methods, spacing: 2)153  }154  155  /// Modifiers specifically for stubbing and verification methods.156  lazy var regularModifiers: String = { return modifiers(allowOverride: false) }()157  /// Modifiers for mocked methods.158  lazy var overridableModifiers: String = { return modifiers(allowOverride: true) }()159  func modifiers(allowOverride: Bool = true) -> String {160    let isRequired = method.attributes.contains(.required)161    let required = (isRequired || method.isInitializer ? "required " : "")162    let shouldOverride = method.isOverridable && !isRequired && allowOverride163    let override = shouldOverride ? "override " : ""164    let `static` = method.kind.typeScope.isStatic ? "static " : ""165    return "\(required)\(override)\(`static`)"166  }167  168  lazy var genericTypes: [String] = {169    return method.genericTypes.map({ $0.flattenedDeclaration })170  }()171  172  lazy var genericConstraints: String = {173    guard !method.whereClauses.isEmpty else { return "" }174    return " where \(separated: method.whereClauses.map({ context.specializeTypeName("\($0)") }))"175  }()176  177  enum FunctionVariant {178    case function, subscriptGetter, subscriptSetter179    180    var isSubscript: Bool {181      switch self {182      case .function: return false183      case .subscriptGetter, .subscriptSetter: return true184      }185    }186  }187  188  enum FullNameMode {189    case mocking(variant: FunctionVariant)190    case matching(useVariadics: Bool, variant: FunctionVariant)191    case initializerProxy192    193    var isMatching: Bool {194      switch self {195      case .matching: return true196      case .mocking, .initializerProxy: return false197      }198    }199    200    var isInitializerProxy: Bool {201      switch self {202      case .matching, .mocking: return false203      case .initializerProxy: return true204      }205    }206    207    var useVariadics: Bool {208      switch self {209      case .matching(let useVariadics, _): return useVariadics210      case .mocking, .initializerProxy: return false211      }212    }213    214    var variant: FunctionVariant {215      switch self {216      case .matching(_, let variant), .mocking(let variant): return variant217      case .initializerProxy: return .function218      }219    }220  }221  222  func shortName(for mode: FullNameMode) -> String {223    let failable: String224    if mode.isInitializerProxy {225      failable = ""226    } else if method.attributes.contains(.failable) {227      failable = "?"228    } else if method.attributes.contains(.unwrappedFailable) {229      failable = "!"230    } else {231      failable = ""232    }233    234    // Don't escape initializers, subscripts, and special functions with reserved tokens like `==`.235    let shouldEscape = !method.isInitializer236      && method.kind != .functionSubscript237      && (method.shortName.first?.isLetter == true238        || method.shortName.first?.isNumber == true239        || method.shortName.first == "_")240    let escapedShortName = mode.isInitializerProxy ? "initialize" :241      (shouldEscape ? method.shortName.backtickWrapped : method.shortName)242    243    return genericTypes.isEmpty244      ? "\(escapedShortName)\(failable)"245      : "\(escapedShortName)\(failable)<\(separated: genericTypes)>"246  }247  248  lazy var fullNameForMocking: String = {249    return fullName(for: .mocking(variant: .function))250  }()251  lazy var fullNameForMatching: String = {252    return fullName(for: .matching(useVariadics: false, variant: .function))253  }()254  /// It's not possible to have an autoclosure with variadics. However, since a method can only have255  /// one variadic parameter, we can generate one method for wildcard matching using an argument256  /// matcher, and another for specific matching using variadics.257  lazy var fullNameForMatchingVariadics: String = {258    return fullName(for: .matching(useVariadics: true, variant: .function))259  }()260  func fullName(for mode: FullNameMode) -> String {261    let additionalParameters: [String]262    if mode.isInitializerProxy {263      additionalParameters = ["__file: StaticString = #file", "__line: UInt = #line"]264    } else if mode.variant == .subscriptSetter {265      let closureType = mode.isMatching ? "@autoclosure () -> " : ""266      additionalParameters = ["`newValue`: \(closureType)\(matchableReturnType)"]267    } else {268      additionalParameters = []269    }270    271    let parameterNames = method.parameters.map({ parameter -> String in272      let typeName: String273      if mode.isMatching && (!mode.useVariadics || !parameter.attributes.contains(.variadic)) {274        typeName = "@autoclosure () -> \(parameter.matchableTypeName(in: self))"275      } else {276        typeName = parameter.mockableTypeName(context: self)277      }278      let argumentLabel = parameter.argumentLabel ?? "_"279      let parameterName = parameter.name.backtickWrapped280      if argumentLabel.backtickUnwrapped != parameter.name {281        return "\(argumentLabel) \(parameterName): \(typeName)"282      } else if mode.isMatching && mode.variant.isSubscript {283        // Synthesized declarations for subscripts don't use argument labels (unless the parameter284        // name differs) for parity with bracket syntax.285        return "_ \(parameterName): \(typeName)"286      } else {287        return "\(parameterName): \(typeName)"288      }289    }) + additionalParameters290    291    let actualShortName = shortName(for: mode)292    let shortName: String293    if mode.isMatching, let resolvedShortName = Constants.reservedNamesMap[actualShortName] {294      shortName = resolvedShortName295    } else {296      shortName = actualShortName297    }298    299    return "\(shortName)(\(separated: parameterNames))"300  }301  302  lazy var mockableInvocation: String = {303    return ObjectInitializationTemplate(304      name: "Mockingbird.SwiftInvocation",305      arguments: [306        ("selectorName", "\(doubleQuoted: uniqueDeclaration)"),307        ("selectorType", "Mockingbird.SelectorType.method"),308        ("arguments", "[\(separated: mockArgumentMatchers)]"),309        ("returnType", "Swift.ObjectIdentifier(\(parenthetical: matchableReturnType).self)"),310      ]).render()311  }()312  313  func matchableInvocation(isVariadic: Bool = false) -> String {314    let matchers = isVariadic ? resolvedVariadicArgumentMatchers : resolvedArgumentMatchers315    return ObjectInitializationTemplate(316      name: "Mockingbird.SwiftInvocation",317      arguments: [318        ("selectorName", "\(doubleQuoted: uniqueDeclaration)"),319        ("selectorType", "Mockingbird.SelectorType.method"),320        ("arguments", "[\(matchers)]"),321        ("returnType", "Swift.ObjectIdentifier(\(parenthetical: matchableReturnType).self)"),322      ]).render()323  }324  325  lazy var resolvedArgumentMatchers: String = {326    return self.resolvedArgumentMatchers(for: method.parameters.map({ ($0.name, true) }))327  }()...

1import Foundation2class TestClass{3    func testMethod() {4        print("Hello World")5    }6}7let testClass = TestClass()8let testClassMirror = Mirror(reflecting: testClass)9let testMethod = testClassMirror.children.first?.value as! (() -> Void)10let methodTemplate = MethodTemplate(method: testMethod)11let invocation = methodTemplate.matchableInvocation()12print(invocation)13import Foundation14class TestClass{15    func testMethod() {16        print("Hello World")17    }18}19let testClass = TestClass()20let testClassMirror = Mirror(reflecting: testClass)21let testMethod = testClassMirror.children.first?.value as! (() -> Void)22let methodTemplate = MethodTemplate(method: testMethod)23let invocation = methodTemplate.matchableInvocation()24print(invocation)25import Foundation26class TestClass{27    func testMethod() {28        print("Hello World")29    }30}31let testClass = TestClass()32let testClassMirror = Mirror(reflecting: testClass)33let testMethod = testClassMirror.children.first?.value as! (() -> Void)34let methodTemplate = MethodTemplate(method: testMethod)35let invocation = methodTemplate.matchableInvocation()36print(invocation)37import Foundation38class TestClass{39    func testMethod() {40        print("Hello World")41    }42}43let testClass = TestClass()44let testClassMirror = Mirror(reflecting: testClass)45let testMethod = testClassMirror.children.first?.value as! (() -> Void)46let methodTemplate = MethodTemplate(method: testMethod)47let invocation = methodTemplate.matchableInvocation()48print(invocation)49import Foundation50class TestClass{51    func testMethod() {52        print("Hello World")53    }54}55let testClass = TestClass()56let testClassMirror = Mirror(reflecting: testClass)57let testMethod = testClassMirror.children.first?.value as! (() -> Void)58let methodTemplate = MethodTemplate(method: testMethod)59let invocation = methodTemplate.matchableInvocation()60print(invocation)

1let methodTemplate = MethodTemplate(name: "test", returnType: .int, parameters: [ParameterTemplate(name: "a", type: .int)])2let parameterTemplate = ParameterTemplate(name: "a", type: .int)3let propertyTemplate = PropertyTemplate(name: "a", type: .int)4let typeTemplate = TypeTemplate(name: "a", type: .class)5let variableTemplate = VariableTemplate(name: "a", type: .int)6let variableTemplate = VariableTemplate(name: "a", type: .int)7let variableTemplate = VariableTemplate(name: "a", type: .int)8let variableTemplate = VariableTemplate(name: "a", type: .int)9let variableTemplate = VariableTemplate(name: "a", type: .int)

1import Foundation2class MatchableInvocation {3    init(method: String, arguments: [String], returnType: String) {4    }5    func matchableInvocation() -> String {6        var invocation = "\(method)("7        for (index, argument) in arguments.enumerated() {8            invocation += "\(argument): arg\(index)"9            if index < arguments.count - 1 {10            }11        }12        invocation += ") -> \(returnType)"13    }14}15let matchableInvocation = MatchableInvocation(method: "method", arguments: ["arg1", "arg2"], returnType: "returnType")16print(matchableInvocation.matchableInvocation())17import Foundation18class MatchableInvocation {19    init(method: String, arguments: [String], returnType: String) {20    }21    func matchableInvocation() -> String {22        var invocation = "\(method)("23        for (index, argument) in arguments.enumerated() {24            invocation += "\(argument): arg\(index)"25            if index < arguments.count - 1 {26            }27        }28        invocation += ") -> \(returnType)"29    }30}31let matchableInvocation = MatchableInvocation(method: "method", arguments: ["arg1", "arg2"], returnType: "returnType")32print(matchableInvocation.matchableInvocation())33import Foundation34class MatchableInvocation {35    init(method: String, arguments: [String], returnType: String) {36    }37    func matchableInvocation() -> String {

1import MethodTemplate2var methodTemplate = MethodTemplate()3methodTemplate.matchableInvocation()4import MethodTemplate5var methodTemplate = MethodTemplate()6methodTemplate.matchableInvocation()7import MethodTemplate8var methodTemplate = MethodTemplate()9methodTemplate.matchableInvocation()10import MethodTemplate11var methodTemplate = MethodTemplate()12methodTemplate.matchableInvocation()13import MethodTemplate14var methodTemplate = MethodTemplate()15methodTemplate.matchableInvocation()16import MethodTemplate17var methodTemplate = MethodTemplate()18methodTemplate.matchableInvocation()19import MethodTemplate20var methodTemplate = MethodTemplate()21methodTemplate.matchableInvocation()22import MethodTemplate23var methodTemplate = MethodTemplate()24methodTemplate.matchableInvocation()25import MethodTemplate26var methodTemplate = MethodTemplate()27methodTemplate.matchableInvocation()28import MethodTemplate29var methodTemplate = MethodTemplate()30methodTemplate.matchableInvocation()31import MethodTemplate

1import Foundation2import MethodTemplate3class MyObject {4    func myMethod(_ string: String, integer: Int) {5        print("myMethod called with \(string) and \(integer)")6    }7}8let myObject = MyObject()9let method = MethodTemplate(object: myObject, selector: #selector(MyObject.myMethod(_:integer:)))10let invocation = method.matchableInvocation(with: ["string1", 1])11myObject.perform(invocation)12import Foundation13import MethodTemplate14class MyObject {15    func myMethod(_ string: String, integer: Int) {16        print("myMethod called with \(string) and \(integer)")17    }18}19let myObject = MyObject()20let method = MethodTemplate(object: myObject, selector: #selector(MyObject.myMethod(_:integer:)))21let invocation = method.matchableInvocation(with: ["string1", 1])22myObject.perform(invocation)23import Foundation24import MethodTemplate25class MyObject {26    func myMethod(_ string: String, integer: Int) {27        print("myMethod called with \(string) and \(integer)")28    }29}30let myObject = MyObject()31let method = MethodTemplate(object: myObject, selector: #selector(MyObject.myMethod(_:integer:)))32let invocation = method.matchableInvocation(with: ["string1", 1])33myObject.perform(invocation)34import Foundation35import MethodTemplate36class MyObject {37    func myMethod(_ string: String, integer: Int) {38        print("myMethod called with \(string) and \(integer)")39    }40}41let myObject = MyObject()42let method = MethodTemplate(object: myObject, selector: #selector(MyObject.myMethod(_:integer:)))43let invocation = method.matchableInvocation(with: ["string1", 1])44myObject.perform(invocation)45import Foundation46import MethodTemplate47class MyObject {48    func myMethod(_ string: String, integer: Int) {49        print("myMethod called with \(string) and \(integer)")50    }51}

1let methodTemplate = MethodTemplate(name: "test", returnType: .int, parameters: [ParameterTemplate(name: "a", type: .int)])2let parameterTemplate = ParameterTemplate(name: "a", type: .int)3let propertyTemplate = PropertyTemplate(name: "a", type: .int)4let typeTemplate = TypeTemplate(name: "a", type: .class)5let variableTemplate = VariableTemplate(name: "a", type: .int)6let variableTemplate = VariableTemplate(name: "a", type: .int)7let variableTemplate = VariableTemplate(name: "a", type: .int)8let variableTemplate = VariableTemplate(name: "a", type: .int)9let variableTemplate = VariableTemplate(name: "a", type: .int)

1import MethodTemplate2var methodTemplate = MethodTemplate()3methodTemplate.matchableInvocation()4import MethodTemplate5var methodTemplate = MethodTemplate()6methodTemplate.matchableInvocation()7import MethodTemplate8var methodTemplate = MethodTemplate()9methodTemplate.matchableInvocation()10import MethodTemplate11var methodTemplate = MethodTemplate()12methodTemplate.matchableInvocation()13import MethodTemplate14var methodTemplate = MethodTemplate()15methodTemplate.matchableInvocation()16import MethodTemplate17var methodTemplate = MethodTemplate()18methodTemplate.matchableInvocation()19import MethodTemplate20var methodTemplate = MethodTemplate()21methodTemplate.matchableInvocation()22import MethodTemplate23var methodTemplate = MethodTemplate()24methodTemplate.matchableInvocation()25import MethodTemplate26var methodTemplate = MethodTemplate()27methodTemplate.matchableInvocation()28import MethodTemplate29var methodTemplate = MethodTemplate()30methodTemplate.matchableInvocation()31import MethodTemplate

1import Foundation2class A {3    func f() {}4}5let a = A()6let method = MethodTemplate(method: #selector(A.f))7let invocation = NSInvocation(method: method)8invocation.invoke(with: a)9let invocation2 = NSInvocation(method: method)10invocation2.invoke(with: a)11let invocation3 = NSInvocation(method: method)12invocation3.invoke(with: a)13let invocation4 = NSInvocation(method: method)14invocation4.invoke(with: a)15let invocation5 = NSInvocation(method: method)16invocation5.invoke(with: a)17let invocation6 = NSInvocation(method: method)18invocation6.invoke(with: a)19let invocation7 = NSInvocation(method: method)20invocation7.invoke(with: a)21let invocation8 = NSInvocation(method: method)22invocation8.invoke(with: a)23let invocation9 = NSInvocation(method: method)24invocation9.invoke(with: a)25let invocation10 = NSInvocation(method: method)26invocation10.invoke(with: a)27let invocation11 = NSInvocation(method: method)28invocation11.invoke(with: a)29let invocation12 = NSInvocation(method: method)30invocation12.invoke(with: a)31let invocation13 = NSInvocation(method: method)32invocation13.invoke(with: a)33let invocation14 = NSInvocation(method: method)34invocation14.invoke(with: a)35let invocation15 = NSInvocation(method: method)36invocation15.invoke(with: a)37let invocation16 = NSInvocation(method: method)38invocation16.invoke(with: a)39let invocation17 = NSInvocation(method: method)40invocation17.invoke(with: a)41let invocation18 = NSInvocation(method: method)42invocation18.invoke(with: a)43let invocation19 = NSInvocation(method: method)44invocation19.invoke(with: a)45let invocation20 = NSInvocation(method: method)46invocation20.invoke(with: a)47let invocation21 = NSInvocation(method: method)48invocation21.invoke(with: a)49let invocation22 = NSInvocation(method: method)50invocation22.invoke(with: a)51let invocation23 = NSInvocation(method: method)52invocation23.invoke(with: a)53let invocation24 = NSInvocation(method: method)54invocation24.invoke(with: a)55let invocation25 = NSInvocation(method: method)56invocation25.invoke(with: a)

1let methodTemplate = MethodTemplate()2let method = "func test() { }"3let methodTemplate = MethodTemplate()4let method = "func test() { }"5let matchableInvocation = methodTemplate.matchableInvocation(method)6print(matchableInvocation)7let methodTemplate = MethodTemplate()8let template = methodTemplate.template()9print(template)10let methodTemplate = MethodTemplate()11let template = methodTemplate.template()12print(template)13let methodTemplate = MethodTemplate()14let template = methodTemplate.template()15print(template)16let methodTemplate = MethodTemplate()17let template = methodTemplate.template()18print(template)19let methodTemplate = MethodTemplate()20let template = methodTemplate.template()21print(template)22let methodTemplate = MethodTemplate()23let template = methodTemplate.template()24print(template)25let methodTemplate = MethodTemplate()26let template = methodTemplate.template()27print(template)28let methodTemplate = MethodTemplate()29let template = methodTemplate.template()30print(template)31let methodTemplate = MethodTemplate()32let template = methodTemplate.template()33print(template)

1let mock = Mock()2mock.stub(for: matchableInvocation()) { (args) in3}4mock.verify(for: matchableInvocation())5mock.verify(for: matchableInvocation(), called: .exactly(1))6mock.verify(for: matchableInvocation(), called: .atLeast(1))7mock.verify(for: matchableInvocation(), called: .atMost(1))8mock.verify(for: matchableInvocation(), called: .never)