ch.tutteli.atrium.api.cc.infix.en_UK

doc / ch.tutteli.atrium.api.cc.infix.en_UK

Package ch.tutteli.atrium.api.cc.infix.en_UK

@Depreacted API use ch.tutteli.atrium.api.infix.en_GB instead.

Types

case	`object case` `Deprecated`, use `case` from module en_GB, package keywords; will be removed with 1.0.0.
CharSequenceContainsSearchersKt	`object CharSequenceContainsSearchersKt` `Deprecated`, do not use this class, it is only here to retain binary compatibility.
contain	`object contain` `Deprecated`, use `contain` from module en_GB, package keywords; will be removed with 1.0.0.
DefaultTranslationsOf	`class DefaultTranslationsOf` Parameter object to express `Translatable, vararg Translatable` in the infix-api.
Empty	`object Empty` `Deprecated`, use `Empty` from module en_GB, package keywords; will be removed with 1.0.0.
Entries	`class Entries<in T : Any, out A : ((Assert<T>) -> Unit)?>` Parameter object to express `((Assert<T>) -> Unit)?, vararg ((Assert<T>) -> Unit)?` in the infix-api.
Objects	`class Objects<out T>` Parameter object to express `T, vararg T` in the infix-api.
only	`object only` `Deprecated`, use `only` from module en_GB, package keywords; will be removed with 1.0.0.
order	`object order` `Deprecated`, use `order` from module en_GB, package keywords; will be removed with 1.0.0.
RegexPatterns	`class RegexPatterns` Parameter object to express `String, vararg String` in the infix-api.
Values	`class Values<out T>` Parameter object to express `T, vararg T` in the infix-api.

Functions

and	`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.
atLeast	`infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>` Restricts a `contains` assertion by specifying that the number of occurrences of the object which we are looking for, occurs `at least` number of times within the search input. `fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> atLeast(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>` `fun <E, T : Iterable<E>> atLeast(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>` Restricts a `contains` assertion by specifying that the number of occurrences of the entry which we are looking for, occurs `at least` number of times within the Iterable.
atMost	`infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>` Restricts a `contains` assertion by specifying that the number of occurrences of the object which we are looking for, occurs `at least` once but `at most` number of times within the search input. `fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> atMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>` `fun <E, T : Iterable<E>> atMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>` Restricts a `contains` assertion by specifying that the number of occurrences of the entry which we are looking for, occurs `at least` once but `at most` number of times within the Iterable.
but	`infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>` Defines that the constraint "`only` the specified entries exist in the Iterable" shall be applied to this sophisticated `contains` Iterable assertion. `infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderSearchBehaviour>.but(only: only): IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>` Defines that the constraint "`only` the specified entries exist in the Iterable" shall be applied to this sophisticated `contains in order` Iterable assertion.
butAtMost	`infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>` Restricts a `contains at least` assertion by specifying that the number of occurrences of the object which we are looking for, occurs `at most` number of times within the search input. `fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> butAtMost(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>` `fun <E, T : Iterable<E>> butAtMost(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>` Restricts a `contains at least` assertion by specifying that the number of occurrences of the entry which we are looking for, occurs `at most` number of times within the Iterable.
contains	`infix fun <T : CharSequence> Assert<T>.contains(expected: Any): AssertionPlant<T>` Makes the assertion that the Assert.subject contains the toString representation of the given expected using a non disjoint search. `infix fun <T : CharSequence> Assert<T>.contains(values: Values<Any>): AssertionPlant<T>` Makes the assertion that the Assert.subject contains the given values representation using a non disjoint search. `infix fun <T : CharSequence> Assert<T>.contains(defaultTranslationOf: DefaultTranslationsOf): AssertionPlant<T>` Makes the assertion that the Assert.subject contains DefaultTranslationsOf.expected's getDefault representation and the getDefault representations of the DefaultTranslationsOf.otherExpected (if given), using a non disjoint search. `infix fun <T : CharSequence> Assert<T>.contains(patterns: RegexPatterns): AssertionPlant<T>` Makes the assertion that the Assert.subject contains a sequence which matches the given patterns using a non disjoint search. `infix fun <E, T : Iterable<E>> Assert<T>.contains(expected: E): AssertionPlant<T>` Makes the assertion that the Assert.subject contains the expected value. `infix fun <E, T : Iterable<E>> Assert<T>.contains(values: Values<E>): AssertionPlant<T>` Makes the assertion that the Assert.subject contains the expected values. `infix fun <E, T : Iterable<E>> Assert<T>.contains(objects: Objects<E>): AssertionPlant<T>` Makes the assertion that the Assert.subject contains the expected objects. `infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>` Makes the assertion that the Assert.subject contains an entry holding the assertions created by the assertionCreator where it does not matter in which order the entries appear. `infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>` Makes the assertion that the Assert.subject contains an entry holding the assertions created by the Entries.assertionCreator and an additional entry for each Entries.otherAssertionCreators (if given) where it does not matter in which order the entries appear.
containsDefaultTranslationOf	`infix fun <T : CharSequence> Assert<T>.containsDefaultTranslationOf(translatable: Translatable): AssertionPlant<T>` Makes the assertion that the Assert.subject contains the getDefault representation of the given translatable.
containsNot	`infix fun <T : CharSequence> Assert<T>.containsNot(expected: Any): AssertionPlant<T>` Makes the assertion that the Assert.subject does not expected's toString representation. `infix fun <T : CharSequence> Assert<T>.containsNot(values: Values<Any>): AssertionPlant<T>` Makes the assertion that the Assert.subject does not contain the toString representation of the given values. `infix fun <T : CharSequence> Assert<T>.containsNot(defaultTranslationsOf: DefaultTranslationsOf): AssertionPlant<T>` Makes the assertion that the Assert.subject does not contain DefaultTranslationsOf.expected's getDefault representation and neither one of the DefaultTranslationsOf.otherExpected's getDefault representation (if given). `infix fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E): AssertionPlant<T>` Makes the assertion that the Assert.subject does not contain the expected value. `infix fun <E, T : Iterable<E>> Assert<T>.containsNot(values: Values<E>): AssertionPlant<T>` Makes the assertion that the Assert.subject does not contain the expected values. `infix fun <E, T : Iterable<E>> Assert<T>.containsNot(objects: Objects<E>): AssertionPlant<T>` Makes the assertion that the Assert.subject does not contain the expected objects.
containsNullable	`fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>` `fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>`
containsRegex	`infix fun <T : CharSequence> Assert<T>.containsRegex(pattern: String): AssertionPlant<T>` Makes the assertion that the Assert.subject contains a sequence which matches the given pattern.
containsStrictly	`infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: E): AssertionPlant<T>` Makes the assertion that the Assert.subject contains only the expected value. `infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(values: Values<E>): AssertionPlant<T>` Makes the assertion that the Assert.subject contains only the expected values in the defined order. `infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(objects: Objects<E>): AssertionPlant<T>` Makes the assertion that the Assert.subject contains only the expected objects in the defined order. `infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>` Makes the assertion that the Assert.subject contains only one entry which is holding the assertions created by the assertionCreator. `infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>` Makes the assertion that the Assert.subject contains only an entry holding the assertions created by the Entries.assertionCreator and an additional entry for each Entries.otherAssertionCreators (if given) in the defined order holding the assertions created by them.
containsStrictlyNullable	`fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>` `fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>`
defaultTranslationOf	`infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the getDefault representation of the given translatable shall be searched, using a non disjoint search. `infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the getDefault representation of the given translatable shall be searched (ignoring case), using a non disjoint search.
endsNotWith	`infix fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>` Makes the assertion that the Assert.subject does not end with expected.
endsWith	`infix fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>` Makes the assertion that the Assert.subject ends with expected.
entry	`infix fun <E : Any, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where an entry shall be searched which holds all assertions assertionCreator might create. `fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>` `fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>` `fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>infix fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>` `infix fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the Iterable needs to contain only one entry which holds all assertions created by the given assertionCreator.
exactly	`infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>` Restricts a `contains` assertion by specifying that the number of occurrences of the object which we are looking for, occurs `exactly` number of times within the search input. `fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> exactly(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>` `fun <E, T : Iterable<E>> exactly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>` Restricts a `contains` assertion by specifying that the number of occurrences of the entry which we are looking for, occurs `exactly` number of times within the Iterable.
hasSize	`infix fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>` Makes the assertion that the Assert.subject's Collection.size is size.
ignoring	`infix fun <T : CharSequence> CharSequenceContains.Builder<T, NoOpSearchBehaviour>.ignoring(case: case): CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>` Defines that the decoration behaviour `ignore case` shall be applied to this sophisticated `contains` assertion. `fun <T : CharSequence> ignoring(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>, case: case): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>` `fun <T : CharSequence> CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>.ignoring(case: case): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>` Defines that the decoration behaviour `ignore case` shall be applied to this sophisticated `contains not` assertion.
inAny	`infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>` Defines that the search behaviour "find entries `in any order` in the Iterable" shall be applied to this sophisticated `contains` in Iterable assertion. `fun <E, T : Iterable<E>> inAny(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>`
inAnyOrderOnly	`fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>`
inGiven	`infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): IterableContains.Builder<E, T, InOrderSearchBehaviour>` Defines that the search behaviour "find entries `in order` in the Iterable" shall be applied to this sophisticated `contains` in Iterable assertion. `fun <E, T : Iterable<E>> inGiven(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InOrderSearchBehaviour>`
inOrderOnly	`fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>`
isA	`infix 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.
isEqualIncludingScale	`infix 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	`infix 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	`infix fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>` Makes the assertion that the Assert.subject is greater than expected.
isLessOrEquals	`infix 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	`infix fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>` Makes the assertion that the Assert.subject is less than expected.
isNotEqualIncludingScale	`infix 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	`infix fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>` Makes the assertion that the Assert.subject is not numerically equal to expected.
isNotSame	`infix fun <T : Any> Assert<T>.isNotSame(expected: T): AssertionPlant<T>` Makes the assertion that the Assert.subject is not the same instance as expected.
isNumericallyEqualTo	`infix fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>` Makes the assertion that the Assert.subject is numerically equal to expected.
isSame	`infix fun <T : Any> Assert<T>.isSame(expected: T): AssertionPlant<T>` Makes the assertion that the Assert.subject is the same instance as expected.
message	`infix 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 the message ought notToBeNull and uses assertionCreator which might create further Assertions which are lazily evaluated at the end.
notOrAtMost	`infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>` Restricts a `contains` assertion by specifying that the number of occurrences of the object which we are looking for, occurs `not at all or at most` number of times within the search input. `fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> notOrAtMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>` `fun <E, T : Iterable<E>> notOrAtMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>` Restricts a `contains` assertion by specifying that the number of occurrences of the entry which we are looking for, occurs `not at all or at most` number of times within the Iterable.
notTo	`infix fun <T : CharSequence> Assert<T>.notTo(contain: contain): NotCheckerOption<T, NotSearchBehaviour>` Creates a CharSequenceContains.Builder based on this AssertionPlant which allows to define more sophisticated `contains not` assertions.
notToBe	`infix fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>` Makes the assertion that the Assert.subject is not (equal to) expected. `infix fun <T : CharSequence> Assert<T>.notToBe(onlyEmptyAllowed: Empty): AssertionPlant<T>` Makes the assertion that the Assert.subject CharSequence.kotlin.text.isNotEmpty.
notToBeNull	`infix fun <T : Any> AssertionPlantNullable<T?>.notToBeNull(assertionCreator: Assert<T>.() -> Unit): Unit` Makes the assertion that AssertionPlantNullable.subject is not null and if so, uses assertionCreator which could create further assertions which are added as a group.
nullableEntries	`fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>` `fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>` `fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>`
nullableEntry	`fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>` `fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>` `fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>`
object	`infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.object(expected: E): AssertionPlant<T>` `fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>` `infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>` `fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>` `infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>` `fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>`
property	`fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<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: AssertionPlant<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.
regex	`infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the given regular expression pattern is expected to have a match, using a non disjoint search. `infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the given regular expression pattern is expected to have a match (ignoring case), using a non disjoint search.
returnValueOf	`fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>` 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, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>` 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.
startsNotWith	`infix fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>` Makes the assertion that the Assert.subject does not start with expected.
startsWith	`infix fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>` Makes the assertion that the Assert.subject starts with expected.
the	`infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the given values shall be searched, using a non disjoint search. `infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the values shall be searched (ignoring case), using a non disjoint search. `infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the getDefault representation of the given translatables shall be searched, using a non disjoint search. `infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the getDefault representation of the given translatables shall be searched (ignoring case), using a non disjoint search. `infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the given regular expression patterns are expected to have a match, using a non disjoint search. `infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the given regular expression patterns are expected to have a match (ignoring case), using a non disjoint search. `infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the expected values shall be searched within the Iterable. `fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, values: Values<E>): AssertionPlant<T>` `infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>` `fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, objects: Objects<E>): AssertionPlant<T>` `fun <E : Any, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>` `fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>` `infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>` `fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>` `fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>` `fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>` `infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>` `fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>` `fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>infix fun <E : Any, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where an entry shall be searched which holds all assertions Entries.assertionCreator might create and search for entries which hold (one by one) the assertions created by the Entries.otherAssertionCreators. `infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the expected values need to be contained in Iterable where it does not matter in which order. `infix fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the entry needs to be contained in the Iterable which holds all assertions Entries.assertionCreator might create -- equally an entry for each further Entries.otherAssertionCreators needs to be contained in the Iterable where it does not matter in which order the entries appear. `infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the expected values need to be contained in Iterable in the specified order. `infix fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the entry needs to be contained in the Iterable which holds all assertions Entries.assertionCreator might create -- equally an entry for each further Entries.otherAssertionCreators, following the specified order, needs to be contained in the Iterable
to	`infix fun <T : CharSequence> Assert<T>.to(contain: contain): CharSequenceContains.Builder<T, NoOpSearchBehaviour>` Creates a CharSequenceContains.Builder based on this AssertionPlant which allows to define a sophisticated `contains` assertions.
toBe	`infix fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>` Makes the assertion that the Assert.subject is (equal to) expected. `infix fun <T> AssertionPlantNullable<T>.toBe(null: Nothing?): Unit` Makes the assertion that the Assert.subject is `null`. `infix fun <T : CharSequence> Assert<T>.toBe(Empty: Empty): AssertionPlant<T>` Makes the assertion that the Assert.subject CharSequence.kotlin.text.isEmpty.
toThrow	`fun <TExpected : Throwable> ThrowableThrown.Builder.toThrow(): Unit` Makes the assertion that the thrown Throwable is of type TExpected. `infix fun <TExpected : Throwable> ThrowableThrown.Builder.toThrow(assertionCreator: Assert<TExpected>.() -> Unit): Unit` Makes the assertion that the thrown Throwable is of type TExpected and holds all assertions the assertionCreator might create in addition.
value	`infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the expected object shall be searched, using a non disjoint search. `infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the expected object shall be searched (ignoring case), using a non disjoint search. `infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the expected value shall be searched within the Iterable. `fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>` `fun <E, T : Iterable<E>> value(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>` `infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>` Finishes the specification of the sophisticated `contains` assertion where the Iterable needs to contain only the expected value.