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

How to use shortName method of MethodTemplate class

Best Mockingbird code snippet using MethodTemplate.shortName

MethodTemplate.swift

Source:MethodTemplate.swift

...64                    isBridged: false,65                    isThrowing: method.isThrowing,66                    isStatic: method.kind.typeScope.isStatic,67                    callMember: { scope in68                      let scopedName = "\(scope).\(backticked: self.method.shortName)"69                      guard self.method.isVariadic else {70                        return FunctionCallTemplate(71                          name: scopedName,72                          arguments: self.invocationArguments,73                          isThrowing: self.method.isThrowing).render()74                      }75                      76                      // Variadic functions require casting since Swift doesn't support splatting.77                      let name = FunctionCallTemplate(78                        name: "Swift.unsafeBitCast",79                        arguments: [80                          (nil, "\(scopedName) as \(self.originalSignature)"),81                          ("to", "\(parenthetical: self.longSignature).self")])82                      return FunctionCallTemplate(83                        name: name.render(),84                        unlabeledArguments: self.invocationArguments.map({ $0.parameterName }),85                        isThrowing: self.method.isThrowing).render()86                    },87                    invocationArguments: invocationArguments).render()88    let declaration = "public \(overridableModifiers)func \(fullNameForMocking)\(returnTypeAttributesForMocking) -> \(mockableReturnType)"89    return String(lines: [90      "// MARK: Mocked \(fullNameForMocking)",91      FunctionDefinitionTemplate(attributes: method.attributes.safeDeclarations,92                                 declaration: declaration,93                                 genericConstraints: method.whereClauses.map({ context.specializeTypeName("\($0)") }),94                                 body: body).render(),95    ])96  }97  98  /// Declared in a class, or a class that the protocol conforms to.99  lazy var isClassBound: Bool = {100    let isClassDefinedProtocolConformance = context.protocolClassConformance != nil101      && method.isOverridable102    return context.mockableType.kind == .class || isClassDefinedProtocolConformance103  }()104  105  var overridableUniqueDeclaration: String {106    return "\(fullNameForMocking)\(returnTypeAttributesForMocking) -> \(mockableReturnType)\(genericConstraints)"107  }108  109  lazy var uniqueDeclaration: String = { return overridableUniqueDeclaration }()110  111  /// Methods synthesized specifically for the stubbing and verification APIs.112  var synthesizedDeclarations: String {113    let invocationType = "(\(separated: matchableParameterTypes)) \(returnTypeAttributesForMatching)-> \(matchableReturnType)"114    115    var methods = [String]()116    let genericTypes = [declarationTypeForMocking, invocationType, matchableReturnType]117    let returnType = "Mockingbird.Mockable<\(separated: genericTypes)>"118    119    let declaration = "public \(regularModifiers)func \(fullNameForMatching) -> \(returnType)"120    let genericConstraints = method.whereClauses.map({ context.specializeTypeName("\($0)") })121    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 {...

shortName

Using AI Code Generation

1let method = MethodTemplate()2let shortName = method.shortName("Hello World")3print(shortName)4let method = MethodTemplate()5let longName = method.longName("Hello World")6print(longName)7let method = MethodTemplate()8let shortName = method.shortName("Hello World")9print(shortName)10let method = MethodTemplate()11let longName = method.longName("Hello World")12print(longName)13let method = MethodTemplate()14let shortName = method.shortName("Hello World")15print(shortName)16let method = MethodTemplate()17let longName = method.longName("Hello World")18print(longName)19let method = MethodTemplate()20let shortName = method.shortName("Hello World")21print(shortName)22let method = MethodTemplate()23let longName = method.longName("Hello World")24print(longName)25let method = MethodTemplate()26let shortName = method.shortName("Hello World")27print(shortName)28let method = MethodTemplate()29let longName = method.longName("Hello World")30print(longName)31let method = MethodTemplate()32let shortName = method.shortName("Hello World")33print(shortName)34let method = MethodTemplate()35let longName = method.longName("Hello World")36print(longName)37let method = MethodTemplate()38let shortName = method.shortName("Hello World")

shortName

Using AI Code Generation

1let template = MethodTemplate()2template.shortName("Swift is awesome")3let template = MethodTemplate()4template.shortName("Swift is awesome")5let template = MethodTemplate()6template.shortName("Swift is awesome")7let template = MethodTemplate()8template.shortName("Swift is awesome")9let template = MethodTemplate()10template.shortName("Swift is awesome")11let template = MethodTemplate()12template.shortName("Swift is awesome")13let template = MethodTemplate()14template.shortName("Swift is awesome")15let template = MethodTemplate()16template.shortName("Swift is awesome")17let template = MethodTemplate()18template.shortName("Swift is awesome")19let template = MethodTemplate()20template.shortName("Swift is awesome")21let template = MethodTemplate()22template.shortName("Swift is awesome")23let template = MethodTemplate()24template.shortName("Swift is awesome")25let template = MethodTemplate()26template.shortName("Swift is awesome")27let template = MethodTemplate()28template.shortName("Swift is awesome")29let template = MethodTemplate()30template.shortName("Swift is awesome")

shortName

Using AI Code Generation

1let method = MethodTemplate("myMethod")2let shortName = method.shortName()3print(shortName)4let method = MethodTemplate("myMethod")5let shortName = method.shortName()6print(shortName)7let method = MethodTemplate("myMethod")8let shortName = method.shortName()9print(shortName)10let method = MethodTemplate("myMethod")11let shortName = method.shortName()12print(shortName)13let method = MethodTemplate("myMethod")14let shortName = method.shortName()15print(shortName)16let method = MethodTemplate("myMethod")17let shortName = method.shortName()18print(shortName)19let method = MethodTemplate("myMethod")20let shortName = method.shortName()21print(shortName)22let method = MethodTemplate("myMethod")23let shortName = method.shortName()24print(shortName)25let method = MethodTemplate("myMethod")26let shortName = method.shortName()27print(shortName)28let method = MethodTemplate("myMethod")29let shortName = method.shortName()30print(shortName)31let method = MethodTemplate("myMethod")32let shortName = method.shortName()33print(shortName)34let method = MethodTemplate("myMethod")35let shortName = method.shortName()36print(shortName)37let method = MethodTemplate("myMethod")38let shortName = method.shortName()

shortName

Using AI Code Generation

1import Foundation2let method = MethodTemplate(name: "foo", shortName: "bar")3print(method.shortName)4import Foundation5let method = MethodTemplate(name: "foo", shortName: "bar")6print(method.shortName)7import Foundation8let method = MethodTemplate(name: "foo", shortName: "bar")9print(method.shortName)10import Foundation11let method = MethodTemplate(name: "foo", shortName: "bar")12print(method.shortName)13import Foundation14let method = MethodTemplate(name: "foo", shortName: "bar")15print(method.shortName)16import Foundation17let method = MethodTemplate(name: "foo", shortName: "bar")18print(method.shortName)19import Foundation20let method = MethodTemplate(name: "foo", shortName: "bar")21print(method.shortName)22import Foundation23let method = MethodTemplate(name: "foo", shortName: "bar")24print(method.shortName)25import Foundation26let method = MethodTemplate(name: "foo", shortName: "bar")27print(method.shortName)28import Foundation29let method = MethodTemplate(name: "foo", shortName: "bar")30print(method.shortName)31import Foundation32let method = MethodTemplate(name: "foo", shortName: "bar")33print(method.shortName)34import Foundation35let method = MethodTemplate(name: "foo", shortName: "bar")36print(method.shortName)

shortName

Using AI Code Generation

1import Foundation2var obj = MethodTemplate()3obj.shortName("Karthik")4import Foundation5var obj = MethodTemplate()6obj.shortName("Karthik", "Murali")7import Foundation8var obj = MethodTemplate()9obj.shortName("Karthik", "Murali", "Kumar")10import Foundation11var obj = MethodTemplate()12obj.shortName("Karthik", "Murali", "Kumar", "S")13import Foundation14var obj = MethodTemplate()15obj.shortName("Karthik", "Murali", "Kumar", "S", "B")16import Foundation17var obj = MethodTemplate()18obj.shortName("Karthik", "Murali", "Kumar", "S", "B", "M")19import Foundation20var obj = MethodTemplate()21obj.shortName("Karthik", "Murali", "Kumar", "S", "B", "M", "S")

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.