KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use matchableInvocation method of MethodTemplate class

Best Mockingbird code snippet using MethodTemplate.matchableInvocation

MethodTemplate.swift

Source:MethodTemplate.swift

...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  }()...

matchableInvocation

Using AI Code Generation

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)

matchableInvocation

Using AI Code Generation

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)

matchableInvocation

Using AI Code Generation

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 {

matchableInvocation

Using AI Code Generation

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

matchableInvocation

Using AI Code Generation

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}

matchableInvocation

Using AI Code Generation

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)

matchableInvocation

Using AI Code Generation

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

matchableInvocation

Using AI Code Generation

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)

matchableInvocation

Using AI Code Generation

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)

matchableInvocation

Using AI Code Generation

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)

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.