atrium-api-cc-en_GB-jvm / ch.tutteli.atrium.api.cc.en_GB / ch.tutteli.atrium.creating.AssertionPlant

Extensions for ch.tutteli.atrium.creating.AssertionPlant

all

fun <E : Any, T : Iterable<E?>> Assert<T>.all(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

Makes the assertion that the Assert.subject has at least one element and that every element holds all assertions created by the assertionCreatorOrNull or that all elements are null in case assertionCreatorOrNull is defined as null.

allOfNullable

fun <E : Any, T : Iterable<E?>> Assert<T>.allOfNullable(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

and

val <T : Any> AssertionPlant<T>.and: AssertionPlant<T>

Can be used to separate assertions when using the fluent API.

infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>

Can be used to create a group of sub assertions when using the fluent API.

any

fun <E : Any, T : Iterable<E?>> Assert<T>.any(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

Makes the assertion that the Assert.subject contains an entry holding the assertions created by assertionCreatorOrNull or an entry which is null in case assertionCreatorOrNull is defined as null.

anyOfNullable

fun <E : Any, T : Iterable<E?>> Assert<T>.anyOfNullable(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

asEntries

fun <K, V> Assert<Map<out K, V>>.asEntries(): Assert<Set<Entry<K, V>>>

Turns Assert<Map<K, V>> into Assert<Set<Map.Entry<K, V>>>.

fun <K, V> Assert<Map<out K, V>>.asEntries(assertionCreator: Assert<Set<Entry<K, V>>>.() -> Unit): Assert<Set<Entry<K, V>>>

Turns Assert<Map<K, V>> into Assert<Set<Map.Entry<K, V>>> and makes the assertion that the assertions the given assertionCreator might create hold.

asIterable

fun <E> Assert<Array<out E>>.asIterable(): Assert<Iterable<E>>

Turns Assert<Array<E>> into Assert<Iterable<E>>.

fun <E> Assert<Array<out E>>.asIterable(assertionCreator: Assert<Iterable<E>>.() -> Unit): Assert<Iterable<E>>

Turns Assert<Array<E>> into Assert<Iterable<E>> and makes the assertion that the assertions the given assertionCreator might create hold.

fun Assert<ByteArray>.asIterable(): Assert<Iterable<Byte>>

Turns Assert<CharArray> into Assert<Iterable<Byte>>.

fun Assert<ByteArray>.asIterable(assertionCreator: Assert<Iterable<Byte>>.() -> Unit): Assert<Iterable<Byte>>

Turns Assert<CharArray> into Assert<Iterable<Byte>> and makes the assertion that the assertions the given assertionCreator might create hold.

fun Assert<CharArray>.asIterable(): Assert<Iterable<Char>>

Turns Assert<CharArray> into Assert<Iterable<Char>>.

fun Assert<CharArray>.asIterable(assertionCreator: Assert<Iterable<Char>>.() -> Unit): Assert<Iterable<Char>>

Turns Assert<CharArray> into Assert<Iterable<Char>> and makes the assertion that the assertions the given assertionCreator might create hold.

fun Assert<ShortArray>.asIterable(): Assert<Iterable<Short>>

Turns Assert<ShortArray> into Assert<Iterable<Short>>.

fun Assert<ShortArray>.asIterable(assertionCreator: Assert<Iterable<Short>>.() -> Unit): Assert<Iterable<Short>>

Turns Assert<ShortArray> into Assert<Iterable<Short>> and makes the assertion that the assertions the given assertionCreator might create hold.

fun Assert<IntArray>.asIterable(): Assert<Iterable<Int>>

Turns Assert<IntArray> into Assert<Iterable<Int>>.

fun Assert<IntArray>.asIterable(assertionCreator: Assert<Iterable<Int>>.() -> Unit): Assert<Iterable<Int>>

Turns Assert<IntArray> into Assert<Iterable<Int>> and makes the assertion that the assertions the given assertionCreator might create hold.

fun Assert<LongArray>.asIterable(): Assert<Iterable<Long>>

Turns Assert<LongArray> into Assert<Iterable<Double>>.

fun Assert<LongArray>.asIterable(assertionCreator: Assert<Iterable<Long>>.() -> Unit): Assert<Iterable<Long>>

Turns Assert<LongArray> into Assert<Iterable<Double>> and makes the assertion that the assertions the given assertionCreator might create hold.

fun Assert<FloatArray>.asIterable(): Assert<Iterable<Float>>

Turns Assert<FloatArray> into Assert<Iterable<Float>>.

fun Assert<FloatArray>.asIterable(assertionCreator: Assert<Iterable<Float>>.() -> Unit): Assert<Iterable<Float>>

Turns Assert<FloatArray> into Assert<Iterable<Float>> and makes the assertion that the assertions the given assertionCreator might create hold.

fun Assert<DoubleArray>.asIterable(): Assert<Iterable<Double>>

Turns Assert<DoubleArray> into Assert<Iterable<Double>>.

fun Assert<DoubleArray>.asIterable(assertionCreator: Assert<Iterable<Double>>.() -> Unit): Assert<Iterable<Double>>

Turns Assert<DoubleArray> into Assert<Iterable<Double>> and makes the assertion that the assertions the given assertionCreator might create hold.

fun Assert<BooleanArray>.asIterable(): Assert<Iterable<Boolean>>

Turns Assert<BooleanArray> into Assert<Iterable<Boolean>>.

fun Assert<BooleanArray>.asIterable(assertionCreator: Assert<Iterable<Boolean>>.() -> Unit): Assert<Iterable<Boolean>>

Turns Assert<BooleanArray> into Assert<Iterable<Boolean>> and makes the assertion that the assertions the given assertionCreator might create hold.

fun <E> Assert<Sequence<E>>.asIterable(): Assert<Iterable<E>>

Turns Assert<Sequence<E>> into Assert<Iterable<E>>.

contains

val <T : CharSequence> Assert<T>.contains: Builder<T, NoOpSearchBehaviour>

Creates a CharSequenceContains.Builder based on this AssertionPlant which allows to define more sophisticated contains assertions.

fun <T : CharSequence> Assert<T>.contains(expected: Any, vararg otherExpected: Any): AssertionPlant<T>

Makes the assertion that the Assert.subject contains expected's toString representation and the toString representation of the otherExpected (if given), using a non disjoint search.

fun <E, T : Iterable<E>> Assert<T>.contains(expected: E, vararg otherExpected: E): AssertionPlant<T>

c Makes the assertion that the Assert.subject contains the expected value and the otherExpected values (if given).

fun <E : Any, T : Iterable<E?>> Assert<T>.contains(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

Makes the assertion that the Assert.subject contains an entry holding the assertions created by assertionCreatorOrNull or an entry which is null in case assertionCreatorOrNull is defined as null.

fun <E : Any, T : Iterable<E?>> Assert<T>.contains(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>

Makes the assertion that the Assert.subject contains an entry holding the assertions created by assertionCreatorOrNull or an entry which is null in case assertionCreatorOrNull is defined as null -- likewise an entry (can be the same) is searched for each of the otherAssertionCreatorsOrNulls.

fun <K, V, T : Map<out K, V>> Assert<T>.contains(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): AssertionPlant<T>

Makes the assertion that the Assert.subject contains a key as defined by keyValuePair's Pair.first with a corresponding value as defined by keyValuePair's Pair.second -- optionally the same assertions are created for the otherPairs.

fun <K, V : Any, T : Map<out K, V?>> Assert<T>.contains(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): AssertionPlant<T>

Makes the assertion that the Assert.subject contains a key as defined by keyValue's KeyValue.key with a corresponding value which either holds all assertions keyValue's KeyValue.valueAssertionCreatorOrNull might create or needs to be null in case KeyValue.valueAssertionCreatorOrNull is defined as null -- optionally the same assertions are created for the otherKeyValues.

containsExactly

fun <E, T : Iterable<E>> Assert<T>.containsExactly(expected: E, vararg otherExpected: E): AssertionPlant<T>

Makes the assertion that the Assert.subject contains only the expected value and the otherExpected values (if given) in the defined order.

fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

Makes the assertion that the Assert.subject contains only an entry holding the assertions created by assertionCreatorOrNull or only one entry which is null in case assertionCreatorOrNull is defined as null.

fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>

Makes the assertion that the Assert.subject contains only an entry holding the assertions created by assertionCreatorOrNull or null in case assertionCreatorOrNull is defined as null and likewise an additional entry for each otherAssertionCreatorsOrNulls (if given) whereas the entries have to appear in the defined order.

containsKey

fun <K> Assert<Map<out K, *>>.containsKey(key: K): AssertionPlant<Map<out K, *>>

Makes the assertion that the Assert.subject contains the given key.

containsNot

val <T : CharSequence> Assert<T>.containsNot: NotCheckerOption<T, NotSearchBehaviour>

Creates a CharSequenceContains.Builder based on this AssertionPlant which allows to define more sophisticated contains not assertions.

fun <T : CharSequence> Assert<T>.containsNot(expected: Any, vararg otherExpected: Any): AssertionPlant<T>

Makes the assertion that the Assert.subject does not contain expected's toString representation and neither one of the otherExpected's toString representation (if given).

fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E, vararg otherExpected: E): AssertionPlant<T>

Makes the assertion that the Assert.subject does not contain the expected value and neither one of the otherExpected values (if given).

containsNotKey

fun <K> Assert<Map<out K, *>>.containsNotKey(key: K): AssertionPlant<Map<out K, *>>

Makes the assertion that the Assert.subject does not contain the given key.

containsNullableEntries

fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>

containsNullableEntry

fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

containsNullableValue

fun <E, T : Iterable<E>> Assert<T>.containsNullableValue(expectedOrNull: E): AssertionPlant<T>

containsNullableValues

fun <E, T : Iterable<E>> Assert<T>.containsNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>

containsRegex

fun <T : CharSequence> Assert<T>.containsRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>

Makes the assertion that the Assert.subject contains a sequence which matches the given regular expression pattern as well as the otherPatterns (if given), using a non disjoint search.

containsStrictly

fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>

containsStrictlyNullableEntries

fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>

containsStrictlyNullableEntry

fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

containsStrictlyNullableValue

fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValue(expectedOrNull: E): AssertionPlant<T>

containsStrictlyNullableValues

fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>

endsNotWith

fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>

Makes the assertion that the Assert.subject does not end with expected.

endsWith

fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>

Makes the assertion that the Assert.subject ends with expected.

first

val <K : Any> Assert<Pair<K, *>>.first: Assert<K>

Creates an AssertionPlant for the Assert.subject's property first so that further fluent calls are assertions about it.

fun <K : Any, V> Assert<Pair<K, V>>.first(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Pair<K, V>>

Makes the assertion that the Assert.subject's property first holds all assertions the given assertionCreator might create for it.

get

fun <E : Any, T : List<E>> Assert<T>.get(index: Int): Assert<E>

Makes the assertion that the given index is within the bounds of Assert.subject, creates a feature assertion plant for the corresponding element and returns the newly created plant.

fun <E : Any, T : List<E>> Assert<T>.get(index: Int, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>

Makes the assertion that the given index is within the bounds of Assert.subject and that the corresponding element holds all assertions the given assertionCreator might create for it.

getExisting

fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: K): Assert<V>

Makes the assertion that the Assert.subject contains the given key, creates a feature assertion plant for the corresponding value and returns the newly created plant.

fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: K, assertionCreator: Assert<V>.() -> Unit): AssertionPlant<T>

Makes the assertion that the Assert.subject contains the given key and that the corresponding value holds all assertions the given assertionCreator might create for it.

hasSize

fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>

Makes the assertion that the Assert.subject's Collection.size is size.

isA

fun <TSub : Any> Assert<Any>.isA(assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

Makes the assertion that the Assert.subject is a TSub (the same type or a sub-type) and if so, uses assertionCreator which could create further assertions which are added as a group.

isEmpty

fun <T : CharSequence> Assert<T>.isEmpty(): AssertionPlant<T>

Makes the assertion that the Assert.subject CharSequence.kotlin.text.isEmpty.

isEqualIncludingScale

fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is equal to expected including BigDecimal.scale.

isGreaterOrEquals

fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is greater than or equals expected.

isGreaterThan

fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is greater than expected.

isKeyValue

fun <K : Any, V : Any> Assert<Entry<K, V>>.isKeyValue(key: K, value: V): Assert<Entry<K, V>>

Makes the assertion that the Assert.subject's Map.Entry.key is (equal to) the given key and Map.Entry.value is value.

isLessOrEquals

fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is less than or equals expected.

isLessThan

fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is less than expected.

isNotBlank

fun <T : CharSequence> Assert<T>.isNotBlank(): AssertionPlant<T>

Makes the assertion that the Assert.subject CharSequence.kotlin.text.isNotBlank.

isNotEmpty

fun <T : CharSequence> Assert<T>.isNotEmpty(): AssertionPlant<T>

Makes the assertion that the Assert.subject CharSequence.kotlin.text.isNotEmpty.

isNotEqualIncludingScale

fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is not equal to expected including BigDecimal.scale.

isNotNumericallyEqualTo

fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is not numerically equal to expected.

isNotSameAs

fun <T : Any> Assert<T>.isNotSameAs(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is not the same instance as expected.

isNumericallyEqualTo

fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is numerically equal to expected.

isSameAs

fun <T : Any> Assert<T>.isSameAs(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is the same instance as expected.

key

val <K : Any> Assert<Entry<K, *>>.key: Assert<K>

Creates an AssertionPlant for the Assert.subject's property key so that further fluent calls are assertions about it.

fun <K : Any, V> Assert<Entry<K, V>>.key(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Entry<K, V>>

Makes the assertion that the Assert.subject's property key holds all assertions the given assertionCreator might create for it.

keys

val <K> Assert<Map<K, *>>.keys: Assert<Set<K>>

Creates an AssertionPlant for the Assert.subject's property keys so that further fluent calls are assertions about it.

fun <K, V, T : Map<K, V>> Assert<T>.keys(assertionCreator: Assert<Set<K>>.() -> Unit): AssertionPlant<T>

Makes the assertion that the Assert.subject's property keys holds all assertions the given assertionCreator might create for it.

message

fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit

Creates an AssertionPlantNullable for the message of the plant's subject (which is a Throwable) and makes the assertion that message notToBeNull and uses assertionCreator which might create further Assertions which are lazily evaluated at the end.

messageContains

fun <T : Throwable> Assert<T>.messageContains(expected: Any, vararg otherExpected: Any): Unit

Creates the assertion that the Throwable's message is not null (see message) contains expected's toString representation and the toString representation of the otherExpected (if given), using a non disjoint search.

none

fun <E : Any, T : Iterable<E?>> Assert<T>.none(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

Makes the assertion that the Assert.subject does not contain a single entry which holds all assertions created by assertionCreatorOrNull or does not contain a single entry which is null in case assertionCreatorOrNull is defined as null.

noneOfNullable

fun <E : Any, T : Iterable<E?>> Assert<T>.noneOfNullable(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>

notToBe

fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is not (equal to) expected.

property

fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>

Creates an AssertionPlant for the given property which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the given property, to the current plant.

fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>

Creates an AssertionPlant for the given property which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the given property, to the current plant -- starting with a group consisting of the Assertions created by the assertionCreator lambda.

returnValueOf

fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant.

fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant -- starting with a group consisting of the Assertions created by the assertionCreator lambda.

fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant.

fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant -- starting with a group consisting of the Assertions created by the assertionCreator lambda.

fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1 and arg2, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant.

fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1 and arg2, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant -- starting with a group consisting of the Assertions created by the assertionCreator lambda.

fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1, arg2 and arg3, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant.

fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1, arg2 and arg3, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant -- starting with a group consisting of the Assertions created by the assertionCreator lambda.

fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1, arg2, arg3 and arg4, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant.

fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1, arg2, arg3 and arg4, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant -- starting with a group consisting of the Assertions created by the assertionCreator lambda.

fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1, arg2, arg3, arg4 and arg5, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant.

fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>

Creates an AssertionPlant, for the value returned by calling method with arg1, arg2, arg3, arg4 and arg5, which eventually adds AssertionGroups with a FeatureAssertionGroupType, containing the assertions created for the return value, to the current plant -- starting with a group consisting of the Assertions created by the assertionCreator lambda.

second

val <V : Any> Assert<Pair<*, V>>.second: Assert<V>

Creates an AssertionPlant for the Assert.subject's property second so that further fluent calls are assertions about it.

fun <K, V : Any> Assert<Pair<K, V>>.second(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Pair<K, V>>

Makes the assertion that the Assert.subject's property second holds all assertions the given assertionCreator might create for it.

size

val Assert<Collection<*>>.size: Assert<Int>

Creates an AssertionPlant for the Assert.subject's property size so that further fluent calls are assertions about it.

fun <E, T : Collection<E>> Assert<T>.size(assertionCreator: Assert<Int>.() -> Unit): Assert<T>

Makes the assertion that the Assert.subject's property size holds all assertions the given assertionCreator might create for it.

startsNotWith

fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>

Makes the assertion that the Assert.subject does not start with expected.

startsWith

fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>

Makes the assertion that the Assert.subject starts with expected.

toBe

fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>

Makes the assertion that the Assert.subject is (equal to) expected.

toBeWithErrorTolerance

fun Assert<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): AssertionPlant<Double>
fun Assert<BigDecimal>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): AssertionPlant<BigDecimal>

Makes the assertion that the Assert.subject is equal to expected with an error tolerance (range including bounds).

value

fun <K, V : Any> Assert<Entry<K, V>>.value(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Entry<K, V>>

Makes the assertion that the Assert.subject's property value holds all assertions the given assertionCreator might create for it.

val <V : Any> Assert<Entry<*, V>>.value: Assert<V>

Creates an AssertionPlant for the Assert.subject's property value so that further fluent calls are assertions about it.

values

fun <K, V, T : Map<K, V>> Assert<T>.values(assertionCreator: Assert<Collection<V>>.() -> Unit): AssertionPlant<T>

Makes the assertion that the Assert.subject's property values holds all assertions the given assertionCreator might create for it.

val <V> Assert<Map<*, V>>.values: Assert<Collection<V>>

Creates an AssertionPlant for the Assert.subject's property values so that further fluent calls are assertions about it.