doc / ch.tutteli.atrium.logic.creating.iterable.contains / IterableLikeContains / EntryPointStep

EntryPointStep

interface EntryPointStep<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.EntryPointStep<T, S> (source)

The entry point of the contract.

Use _logic to retrieve the EntryPointStepLogic counterpart in case you want to extend the building process.

Extension Properties

_logic

val <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>._logic: IterableLikeContains.EntryPointStepLogic<E, T, S>

Entry point to the logic level of Atrium -- which is one level deeper than the API -- within the building process of a sophisticated contains assertion for Iterable.

grouped

val <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.grouped: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>

Defines that the IterableLike contains in order only groups of entries whereas the order within the group is specified as next step.

inAnyOrder

val <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inAnyOrder: IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>

Defines that the search behaviour "find entries in any order in the IterableLike" shall be applied to this sophisticated contains in IterableLike assertion.

inOrder

val <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inOrder: IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>

Defines that the search behaviour "find entries in order in the IterableLike" shall be applied to this sophisticated contains in IterableLike assertion.

only

val <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>.only: IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>

Defines that the constraint "only the specified entries exist in the IterableLike" shall be applied to this sophisticated contains IterableLike assertion.

val <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>.only: IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>

Defines that the constraint "only the specified entries exist in the IterableLike" shall be applied to this sophisticated contains in order IterableLike assertion.

within

val <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>.within: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

A filler word to emphasis that the next step defines the order within expected groups of values.

Extension Functions

_logicAppend

fun <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>._logicAppend(factory: IterableLikeContains.EntryPointStepLogic<E, T, S>.() -> Assertion): Expect<T>

Appends the Assertion the given factory creates based on this IterableLikeContains.EntryPointStep.

and

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>.and(only: only): IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>

Defines that the constraint "only the specified entries exist in the IterableLike" shall be applied to this sophisticated contains in order IterableLike assertion.

atLeast

fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atLeast(times: Int): AtLeastCheckerStep<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 IterableLike.

atLeast

infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atLeast(times: Int): AtLeastCheckerStep<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 IterableLike.

atMost

fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atMost(times: Int): AtMostCheckerStep<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 IterableLike.

atMost

infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atMost(times: Int): AtMostCheckerStep<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 IterableLike.

but

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>.but(only: only): IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>

Defines that the constraint "only the specified entries exist in the IterableLike" shall be applied to this sophisticated contains IterableLike assertion.

elementsOf

fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike, report: InAnyOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only and all elements of expectedIterableLike where it does not matter in which order.

fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike, report: InOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only and all elements of expectedIterableLike in the specified order.

elementsOf

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only and all elements of expectedIterableLike where it does not matter in which order.

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only and all elements of expectedIterableLike in the specified order.

entries

fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?, report: InAnyOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only an entry for assertionCreatorOrNull as well as for the otherAssertionCreatorsOrNulls where it does not matter in which order they appear -- an entry is contained if it either holds all assertions assertionCreatorOrNull creates or needs to be null in case assertionCreatorOrNull is defined as null.

fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?, report: InOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only an entry for assertionCreatorOrNull as well as for the otherAssertionCreatorsOrNulls in the specified order -- an entry is contained if it either holds all assertions assertionCreatorOrNull creates or needs to be null in case assertionCreatorOrNull is defined as null.

entry

fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only one entry which holds all assertions created by the given assertionCreatorOrNull or is null in case assertionCreatorOrNull is defined as null.

entry

infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only one entry which holds all assertions created by the given assertionCreatorOrNull or is null in case assertionCreatorOrNull is defined as null.

exactly

fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.exactly(times: Int): ExactlyCheckerStep<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 IterableLike.

exactly

infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.exactly(times: Int): ExactlyCheckerStep<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 IterableLike.

grouped

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.grouped(entries: entries): IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>

Defines that the IterableLike contains in order only groups of entries whereas the order within the group is specified as next step.

inAny

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, Group<E>>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: WithInOrderOnlyReportingOptions<WithInAnyOrderOnlyReportingOptions<Order<E, Group<E>>>>): Expect<T>

Finishes the specification of the sophisticated contains assertion where the expected Order.firstGroup as well as the Order.secondGroup and optionally Order.otherExpectedGroups of values need to be contained in IterableLike in the specified order whereas the values within the groups can occur in any order.

infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<(Expect<E>.() -> Unit)?, Group<(Expect<E>.() -> Unit)?>>): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: WithInOrderOnlyReportingOptions<WithInAnyOrderOnlyReportingOptions<Order<(Expect<E>.() -> Unit)?, Group<(Expect<E>.() -> Unit)?>>>>): Expect<T>

Finishes the specification of the sophisticated contains assertion where the expected Order.firstGroup as well as the Order.secondGroup and optionally Order.otherExpectedGroups of identification lambdas, identifying an entry, need to be contained in IterableLike in the specified order whereas the identification lambdas within the groups can occur in any order.

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inAny(order: order): IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>

Defines that the search behaviour "find entries in any order in the IterableLike" shall be applied to this sophisticated contains in IterableLike assertion.

inAnyOrder

fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>, report: InOrderOnlyReportingOptions.() -> Unit = {}, reportInGroup: InAnyOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>

Finishes the specification of the sophisticated contains assertion where the expected firstGroup as well as the secondGroup and optionally otherExpectedGroups of values need to be contained in IterableLike as only elements and in the specified order whereas the values within the groups can occur in any order.

fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<(Expect<E>.() -> Unit)?>, secondGroup: Group<(Expect<E>.() -> Unit)?>, vararg otherExpectedGroups: Group<(Expect<E>.() -> Unit)?>, report: InOrderOnlyReportingOptions.() -> Unit = {}, reportInGroup: InAnyOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>

Finishes the specification of the sophisticated contains assertion where the expected firstGroup as well as the secondGroup and optionally otherExpectedGroups of identification lambdas, identifying an entry, need to be contained in IterableLike as only elements and in the specified order whereas the identification lambdas within the groups can occur in any order.

inGiven

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inGiven(order: order): IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>

Defines that the search behaviour "find entries in order in the IterableLike" shall be applied to this sophisticated contains in IterableLike assertion.

notOrAtMost

fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<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 IterableLike.

notOrAtMost

infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<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 IterableLike.

the

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.the(values: WithInAnyOrderOnlyReportingOptions<Values<E>>): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only the expected values where it does not matter in which order.

infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.the(entries: WithInAnyOrderOnlyReportingOptions<Entries<E>>): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only the given entries where it does not matter in which order they appear -- an entry is contained if it either holds all assertions entries.assertionCreatorOrNull creates or it needs to be null in case entries.assertionCreatorOrNull is defined as null

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.the(elementsOf: WithInAnyOrderOnlyReportingOptions<IterableLike>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.the(elementsOf: WithInOrderOnlyReportingOptions<IterableLike>): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only and all elements of the given IterableLike in the specified order.

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.the(values: WithInOrderOnlyReportingOptions<Values<E>>): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only the expected values in the specified order.

infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.the(entries: WithInOrderOnlyReportingOptions<Entries<E>>): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only the given entries in the specified order -- an entry is contained if it either holds all assertions entries.assertionCreatorOrNull creates or it needs to be null in case entries.assertionCreatorOrNull is defined as null

value

fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.value(expected: E): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only the expected value.

value

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.value(expected: E): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only the expected value.

values

fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E, report: InAnyOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only the expected value as well as the otherExpected values where it does not matter in which order.

fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E, report: InOrderOnlyReportingOptions.() -> Unit = {}): Expect<T>

Finishes the specification of the sophisticated contains assertion where the subject (an IterableLike) needs to contain only the expected value as well as the otherExpected values in the specified order.

within

infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>.within(group: group): IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

A filler word to emphasis that the next step defines the order within expected groups of values.

Inheritors

EntryPointStepInternal

interface EntryPointStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.EntryPointStep<E, T, S>, IterableLikeContains.EntryPointStepLogic<E, T, S>

Sole purpose of this interface is to hide EntryPointStepLogic from newcomers which usually do not have to deal with this type and to keep the API clean.