doc / ch.tutteli.atrium.logic.creating.charsequence.contains.steps.impl / EntryPointStepImpl

EntryPointStepImpl

class EntryPointStepImpl<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : EntryPointStepImpl<T, S>, CharSequenceContains.EntryPointStepInternal<T, S> (source)

Constructors

<init>

EntryPointStepImpl(container: AssertionContainer<T>, searchBehaviour: S)

Inherited Properties

container

open val container: AssertionContainer<T>

The AssertionContainer from which this building process started and to which the resulting Assertion should be appended.

searchBehaviour

open val searchBehaviour: S

The chosen SearchBehaviour.

Extension Properties

_logic

val <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>._logic: CharSequenceContains.EntryPointStepLogic<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 CharSequence.

Extension Functions

atLeastCheckerStep

fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.atLeastCheckerStep(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): AtLeastCheckerStep<T, S>

atMostCheckerStep

fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.atMostCheckerStep(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): AtMostCheckerStep<T, S>

exactlyCheckerStep

fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.exactlyCheckerStep(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): ExactlyCheckerStep<T, S>

ignoring

infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>.ignoring(case: case): CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>

Defines that the search behaviour ignore case shall be applied to this sophisticated contains assertion.

notCheckerStep

fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.notCheckerStep(): NotCheckerStep<T, S>

notOrAtMostCheckerStep

fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.notOrAtMostCheckerStep(times: Int, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String): NotOrAtMostCheckerStep<T, S>

regex

fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>

Finishes the specification of the sophisticated contains assertion where the given regular expression pattern as well as the otherPatterns are expected to to have at least one match (ignoring case), using a non-disjoint search.

regex

infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): Expect<T>

Finishes the specification of the sophisticated contains assertion where the given regular expression pattern is expected to have at least one match (ignoring case), using a non-disjoint search.

the

infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>

Finishes the specification of the sophisticated contains assertion where the values shall be searched (ignoring case), using a non-disjoint search where each need to be contained at least once.

infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>

Finishes the specification of the sophisticated contains assertion where the given regular expression patterns are expected to have at least one match (ignoring case), using a non-disjoint search.

toVarArg

fun <T> CharSequenceContains.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.

values

fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>

Finishes the specification of the sophisticated contains assertion where the expected value as well as the otherExpected values shall be searched (ignoring case), using a non-disjoint search where each need to be contained at least once.