Parameter

public enum Parameter<ValueType>

Parameter wraps method attribute, allowing to make a difference between explicit value, expressed by .value case and wildcard value, expressed by .any case.

Whole idea is to be able to test and specify behaviours, in both generic and explicit way (and any mix of these two). Every test method matches mock methods in signature, but changes attributes types to Parameter.

That allows pattern like matching between two Parameter values:

.any is equal to every other parameter. (!!! actual case name is ._, but it is advised to use .any)
.value(p1) is equal to .value(p2) only, when p1 == p2

Important! Comparing parameters, where ValueType is not Equatable will result in fatalError, unless you register comparator for its ValueType in Matcher instance used (typically Matcher.default)

any: represents and matches any parameter value
value: represents explicit parameter value

_
Wildcard - any value
Declaration
Swift

case `_`
value(_:)
Explicit value
Declaration
Swift

case value(ValueType)
matching(_:)
Any value matching
Declaration
Swift

case matching((ValueType) -> Bool)
any
Represents and matches any parameter value - syntactic sugar for ._ case.
Declaration
Swift

public static var any: Parameter<ValueType> { get }


                    
                    
                    any(_:)

Represents and matches any parameter value - syntactic sugar for ._ case. Used, when needs to explicitely specify wrapped ValueType type, to resolve ambiguity between methods with same signatures, but different attribute types.

Declaration

Swift

public static func any<T>(_ type: T.Type) -> Parameter<T>

Parameters


                                type

Explicitly specify ValueType type

Return Value

any parameter


                    
                    
                    shortDescription

Undocumented

Declaration

Swift

public var shortDescription: String { get }


                    
                    
                    compare(lhs:rhs:with:)

Returns whether given two parameters are matching each other, with following rules:

if parameter is .any - it is equal to any other parameter
if both are .value - then compare wrapped ValueType instances.
if they are not Equatable (or not a Sequences of Equatable), use provided matcher instance

Declaration

Swift

static func compare(lhs: Parameter<ValueType>, rhs: Parameter<ValueType>, with matcher: Matcher) -> Bool

Parameters

`lhs`	First parameter
`rhs`	Second parameter
`matcher`	Matcher instance

Return Value

true, if first is matching second

wrapAsGeneric()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func wrapAsGeneric() -> Parameter<GenericAttribute>
Return Value

Wrapped parameter
typeErasedAttribute()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func typeErasedAttribute() -> Parameter<TypeErasedAttribute>
Return Value

Wrapped parameter
noComparatorFailure(in:)
[Internal] Fatal error raised when no comparator or default comparator found for ValueType.
Declaration
Swift

static func noComparatorFailure(in matcher: Matcher) -> Swift.Never


                    
                    
                    compare(lhs:rhs:with:)

[Internal] Compare two parameters

Declaration

Swift

static func compare(lhs: Parameter<ValueType>, rhs: Parameter<ValueType>, with matcher: Matcher) -> Bool

Parameters

`lhs`	one
`rhs`	other
`matcher`	Matcher instance used for comparison

Return Value

true if they are matching, false otherwise

Compare using default comparators


                    
                    
                    compare(lhs:rhs:with:)

[Internal] Compare two parameters

Declaration

Swift

static func compare(lhs: Parameter<ValueType>, rhs: Parameter<ValueType>, with matcher: Matcher) -> Bool

Parameters

`lhs`	one
`rhs`	other
`matcher`	Matcher instance used for comparison

Return Value

true if they are matching, false otherwise

wrapAsGeneric()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func wrapAsGeneric() -> Parameter<GenericAttribute>
Return Value

Wrapped parameter
typeErasedAttribute()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func typeErasedAttribute() -> Parameter<TypeErasedAttribute>
Return Value

Wrapped parameter

Compare using default comparators


                    
                    
                    compare(lhs:rhs:with:)

[Internal] Compare two parameters

Declaration

Swift

static func compare(lhs: Parameter<ValueType>, rhs: Parameter<ValueType>, with matcher: Matcher) -> Bool

Parameters

`lhs`	one
`rhs`	other
`matcher`	Matcher instance used for comparison

Return Value

true if they are matching, false otherwise

wrapAsGeneric()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func wrapAsGeneric() -> Parameter<GenericAttribute>
Return Value

Wrapped parameter
typeErasedAttribute()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func typeErasedAttribute() -> Parameter<TypeErasedAttribute>
Return Value

Wrapped parameter

Compare using default comparators


                    
                    
                    compare(lhs:rhs:with:)

[Internal] Compare two parameters

Declaration

Swift

static func compare(lhs: Parameter<ValueType>, rhs: Parameter<ValueType>, with matcher: Matcher) -> Bool

Parameters

`lhs`	one
`rhs`	other
`matcher`	Matcher instance used for comparison

Return Value

true if they are matching, false otherwise

wrapAsGeneric()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func wrapAsGeneric() -> Parameter<GenericAttribute>
Return Value

Wrapped parameter
typeErasedAttribute()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func typeErasedAttribute() -> Parameter<TypeErasedAttribute>
Return Value

Wrapped parameter

Compare using default comparators

Element
Element
Declaration
Swift

typealias Element = ValueType.Element


                    
                    
                    compare(lhs:rhs:with:)

[Internal] Compare two parameters

Declaration

Swift

static func compare(lhs: Parameter<ValueType>, rhs: Parameter<ValueType>, with matcher: Matcher) -> Bool

Parameters

`lhs`	one
`rhs`	other
`matcher`	Matcher instance used for comparison

Return Value

true if they are matching, false otherwise

wrapAsGeneric()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func wrapAsGeneric() -> Parameter<GenericAttribute>
Return Value

Wrapped parameter
typeErasedAttribute()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func typeErasedAttribute() -> Parameter<TypeErasedAttribute>
Return Value

Wrapped parameter

Compare using default comparators


                    
                    
                    compare(lhs:rhs:with:)

[Internal] Compare two parameters

Declaration

Swift

static func compare(lhs: Parameter<ValueType>, rhs: Parameter<ValueType>, with matcher: Matcher) -> Bool

Parameters

`lhs`	one
`rhs`	other
`matcher`	Matcher instance used for comparison

Return Value

true if they are matching, false otherwise

wrapAsGeneric()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func wrapAsGeneric() -> Parameter<GenericAttribute>
Return Value

Wrapped parameter
typeErasedAttribute()
[Internal] Wraps as generic Parameter instance. Should not be ever called directly.
Declaration
Swift

func typeErasedAttribute() -> Parameter<TypeErasedAttribute>
Return Value

Wrapped parameter

Optionality checks


                    
                    
                    notNil

Undocumented

Declaration

Swift

static var notNil: Parameter<ValueType> { get }

Parameter convenience initializers


                    
                    
                    sameInstance(as:)

Represents and matches values on an same instance basis.

Declaration

Swift

static func sameInstance<T>(as instance: T) -> Parameter<ValueType> where T : AnyObject

Parameters


                                instance

Instance to match against


                    
                    
                    isInstance(of:)

Represents and matches whether parameter is of specific type, using is operator.

Declaration

Swift

static func isInstance<T>(of type: T.Type) -> Parameter<ValueType> where T : AnyObject

Parameters


                                type

Type to match against

Parameter convenience initializers


                    
                    
                    all(_:)

Allows combining multiple Parameter constraints into one Parameter constraint.

Declaration

Swift

static func all(_ matching: Parameter<ValueType>...) -> Parameter<ValueType>

Parameters


                                matching

List of parameter constraints

Ordering parameters

intValue
Used for invocations sorting purpose.
Declaration
Swift

var intValue: Int { get }

Ordering parameters

intValue
Used for invocations sorting purpose.
Declaration
Swift

var intValue: Int { get }

ExpressibleByStringLiteral


                    
                    
                    StringLiteralType

Declaration

Swift

public typealias StringLiteralType = ValueType.StringLiteralType


                    
                    
                    ExtendedGraphemeClusterLiteralType

Declaration

Swift

public typealias ExtendedGraphemeClusterLiteralType = ValueType.ExtendedGraphemeClusterLiteralType


                    
                    
                    UnicodeScalarLiteralType

Declaration

Swift

public typealias UnicodeScalarLiteralType = ValueType.UnicodeScalarLiteralType


                    
                    
                    init(stringLiteral:)

Declaration

Swift

public init(stringLiteral value: StringLiteralType)


                    
                    
                    init(extendedGraphemeClusterLiteral:)

Declaration

Swift

public init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType)


                    
                    
                    init(unicodeScalarLiteral:)

Declaration

Swift

public init(unicodeScalarLiteral value: UnicodeScalarLiteralType)

ExpressibleByNilLiteral

init(nilLiteral:)
Declaration
Swift

public init(nilLiteral: ())

ExpressibleByIntegerLiteral


                    
                    
                    IntegerLiteralType

Declaration

Swift

public typealias IntegerLiteralType = ValueType.IntegerLiteralType


                    
                    
                    init(integerLiteral:)

Declaration

Swift

public init(integerLiteral value: ValueType.IntegerLiteralType)

ExpressibleByBooleanLiteral


                    
                    
                    BooleanLiteralType

Declaration

Swift

public typealias BooleanLiteralType = ValueType.BooleanLiteralType


                    
                    
                    init(booleanLiteral:)

Declaration

Swift

public init(booleanLiteral value: BooleanLiteralType)

ExpressibleByFloatLiteral


                    
                    
                    FloatLiteralType

Declaration

Swift

public typealias FloatLiteralType = ValueType.FloatLiteralType


                    
                    
                    init(floatLiteral:)

Declaration

Swift

public init(floatLiteral value: FloatLiteralType)

ExpressibleByArrayLiteral


                    
                    
                    ArrayLiteralElement

Declaration

Swift

public typealias ArrayLiteralElement = ValueType.ArrayLiteralElement


                    
                    
                    init(arrayLiteral:)

Declaration

Swift

public init(arrayLiteral elements: ArrayLiteralElement...)

ExpressibleByDictionaryLiteral

Key
Declaration
Swift

public typealias Key = ValueType.Key


                    
                    
                    Value

Declaration

Swift

public typealias Value = ValueType.Value


                    
                    
                    init(dictionaryLiteral:)

Declaration

Swift

public init(dictionaryLiteral elements: (Key, Value)...)