ch.tutteli.atrium.logic.utils - Atrium 0.15.0

doc / ch.tutteli.atrium.logic.utils

Package ch.tutteli.atrium.logic.utils

Types

ArgumentMapperBuilder	`class ArgumentMapperBuilder<out T>` Builder to map variable length arguments formulated as (first: T, `vararg` others : T) to something else.
ArgumentToNullOrMapperBuilder	`class ArgumentToNullOrMapperBuilder<T : Any>` Builder to map variable length arguments formulated as `(first: T, vararg others : T)` to something else.

Functions

expectLambda	`fun <T> expectLambda(assertionCreator: Expect<T>.() -> Unit): Expect<T>.() -> Unit` Can be used in places where a lambda with receiver is required where the receiver is of type Expect`<T>`.
iterableLikeToIterable	`fun <T> AssertionContainer<*>.iterableLikeToIterable(iterableLike: IterableLike): Iterable<T>` Transforms the given iterableLike to an Iterable with an element type T.
iterableLikeToIterableWithoutCheckForElements	`fun <T> AssertionContainer<*>.iterableLikeToIterableWithoutCheckForElements(iterableLike: IterableLike): Iterable<T>` Transforms the given iterableLike to an Iterable with an element type T.
mapArguments	`fun <T> mapArguments(first: T, others: Array<out T>): ArgumentMapperBuilder<T>` `fun mapArguments(first: Byte, others: ByteArray): ArgumentMapperBuilder<Byte>` `fun mapArguments(first: Char, others: CharArray): ArgumentMapperBuilder<Char>` `fun mapArguments(first: Short, others: ShortArray): ArgumentMapperBuilder<Short>` `fun mapArguments(first: Int, others: IntArray): ArgumentMapperBuilder<Int>` `fun mapArguments(first: Long, others: LongArray): ArgumentMapperBuilder<Long>` `fun mapArguments(first: Float, others: FloatArray): ArgumentMapperBuilder<Float>` `fun mapArguments(first: Double, others: DoubleArray): ArgumentMapperBuilder<Double>` `fun mapArguments(first: Boolean, others: BooleanArray): ArgumentMapperBuilder<Boolean>` Creates a ArgumentMapperBuilder with the given first and others as arguments; specify the mapping as such using a subsequent step in the building process. `fun <T, R> mapArguments(first: T, others: Array<out T>, mapper: (T) -> R): Pair<R, Array<out R>>` `fun <R> mapArguments(first: Byte, others: ByteArray, mapper: (Byte) -> R): Pair<R, Array<out R>>` `fun <R> mapArguments(first: Char, others: CharArray, mapper: (Char) -> R): Pair<R, Array<out R>>` `fun <R> mapArguments(first: Short, others: ShortArray, mapper: (Short) -> R): Pair<R, Array<out R>>` `fun <R> mapArguments(first: Int, others: IntArray, mapper: (Int) -> R): Pair<R, Array<out R>>` `fun <R> mapArguments(first: Long, others: LongArray, mapper: (Long) -> R): Pair<R, Array<out R>>` `fun <R> mapArguments(first: Float, others: FloatArray, mapper: (Float) -> R): Pair<R, Array<out R>>` `fun <R> mapArguments(first: Double, others: DoubleArray, mapper: (Double) -> R): Pair<R, Array<out R>>` `fun <R> mapArguments(first: Boolean, others: BooleanArray, mapper: (Boolean) -> R): Pair<R, Array<out R>>` Maps the given first and others to the given type R with the help of the given mapper.
mapLikeToIterablePair	`fun <K, V> AssertionContainer<*>.mapLikeToIterablePair(mapLike: MapLike): List<Pair<K, V>>` Transforms the given MapLike to `Pair<Pair<K, V>, Array<out Pair<K, V>>>` with the intention that it can be easily used for a function requiring `Pair<K, V>, vararg Pair<K, V>`.
mapLikeToVarArgPairs	`fun <K, V> AssertionContainer<*>.mapLikeToVarArgPairs(mapLike: MapLike): Pair<Pair<K, V>, Array<out Pair<K, V>>>` Transforms the given MapLike to an Iterable with an element type Pair`<K, V>`.
nullable	`fun <T> nullable(t: T): T?` Turns the given type into a nullable type. `fun <T> nullable(t: KFunction0<T>): KFunction0<T?>` `fun <T1, R> nullable(t: KFunction1<T1, R>): KFunction1<T1, R?>` `fun <T1, T2, R> nullable(t: KFunction2<T1, T2, R>): KFunction2<T1, T2, R?>` `fun <T1, T2, T3, R> nullable(t: KFunction3<T1, T2, T3, R>): KFunction3<T1, T2, T3, R?>` `fun <T1, T2, T3, T4, R> nullable(t: KFunction4<T1, T2, T3, T4, R>): KFunction4<T1, T2, T3, T4, R?>` `fun <T1, T2, T3, T4, T5, R> nullable(t: KFunction5<T1, T2, T3, T4, T5, R>): KFunction5<T1, T2, T3, T4, T5, R?>` Turns the given function reference into a function reference with a nullable return type.
nullableContainer	`fun <T> nullableContainer(iterable: Iterable<T>): Iterable<T?>` Turns an Iterable into an iterable with a nullable element type. `fun <T> nullableContainer(arr: Array<out T>): Array<out T?>` Turns an Array into an array with a nullable element type.
nullableKeyMap	`fun <K, V : Any> nullableKeyMap(map: Map<out K, V>): Map<out K?, V>` Turns a Map into a map with a nullable key type.
nullableKeyValueMap	`fun <K, V> nullableKeyValueMap(map: Map<out K, V>): Map<out K?, V?>` Turns a Map into a map with a nullable key and a nullable value type.
nullableValueMap	`fun <K : Any, V> nullableValueMap(map: Map<K, V>): Map<K, V?>` Turns a Map into a map with a nullable value type.
toNullOr	`fun <T : Any> ArgumentMapperBuilder<T?>.toNullOr(): ArgumentToNullOrMapperBuilder<T>` Maps each argument to `null` if it is already `null` and if not, then ...
toVarArg	`fun <T> CharSequenceContains.CheckerStepLogic<, >.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>` `fun <T> CharSequenceContains.EntryPointStepLogic<, >.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>` `fun <T> IterableLikeContains.CheckerStepLogic<, , >.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>` Transforms the given iterableLike to `Pair<T, Array<out T>>` with the intention that it can be easily used for a function requiring `T, vararg T`. `fun <T> IterableLikeContains.EntryPointStepLogic<, , >.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>` Transforms the given iterableLike to `Pair<T, Array<out T>>` with the intention that it can be easily used for a function requiring `T, vararg T`.
toVarArgPairs	`fun <K, V> MapLikeContains.EntryPointStepLogic<, , , >.toVarArgPairs(mapLike: MapLike): Pair<Pair<K, V>, Array<out Pair<K, V>>>` Transforms the given MapLike to `Pair<Pair<K, V>, Array<out Pair<K, V>>>` with the intention that it can be easily used for a function requiring `Pair<K, V>, vararg Pair<K, V>`.