atrium-api-infix/ch.tutteli.atrium.api.infix.en_GB

Package-level declarations

Contains API which provides an infix API in English and which has its design focus on usability in conjunction with code completion.

Types

absolute

object absolute : Keyword

A helper construct to allow expressing expectations about a path being absolute. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

aDirectory

object aDirectory : Keyword

A helper construct to allow expressing expectations about a path being a directory. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

anEmptyDirectory

object anEmptyDirectory : Keyword

A helper construct to allow expressing expectations about a path being an empty directory. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

aRegularFile

object aRegularFile : Keyword

A helper construct to allow expressing expectations about a path being a regular file. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

aSuccess

object aSuccess : Keyword

A helper construct to allow expressing expectations about a something being a success. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

aSymbolicLink

object aSymbolicLink : Keyword

A helper construct to allow expressing expectations about a path being a symbolic link. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

blank

object blank : Keyword

Represents a helper construct which allows expressing blankness. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

case

object case : Keyword

Represents the pseudo keyword case as in ignoring case. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

elements

object elements : Keyword

A helper construct to allow expressing expectations about elements as in expect(iterable) toHave elements. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

empty

object empty : Keyword

Represents a helper construct which allows expressing emptiness. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

entries

object entries : Keyword

Represents the pseudo keyword entries as in grouped entries. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

executable

object executable : Keyword

A helper construct to allow expressing expectations about a path being executable. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

existing

object existing : Keyword

A helper construct to allow expressing expectations about path existence. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

ExperimentalWithOptions

@Target(allowedTargets = [AnnotationTarget.FUNCTION])

annotation class ExperimentalWithOptions

group

object group : Keyword

Represents the pseudo keyword group as in within group. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

Keyword

interface Keyword

Marker interface for keywords.

object next : Keyword

Represents the pseudo keyword next as in toHave next. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

noDuplicates

object noDuplicates : Keyword

A helper construct to allow expressing expectations about iterable contains no duplicates. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

object o : Keyword

Represents a filler, a pseudo keyword where there isn't really a good keyword. A reader should skip this filler without reading it. For instance, contains o atLeast 1... should be read as contains at least once...

only

object only : Keyword

Represents the pseudo keyword only as in and only. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

order

object order : Keyword

Represents the pseudo keyword order as in inAny order. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

present

object present : Keyword

Represents a helper construct which allows expressing presence. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

readable

object readable : Keyword

A helper construct to allow expressing expectations about a path being readable. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

relative

object relative : Keyword

A helper construct to allow expressing expectations about a path being relative. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

writable

object writable : Keyword

A helper construct to allow expressing expectations about a path being writable. It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.

Properties

day

val Expect<LocalDateTime>.day: Expect<Int>

Creates an Expect for the property LocalDateTime.dayOfMonth of the subject of this expectation, so that further fluent calls are assertions about it.

val Expect<LocalDate>.day: Expect<Int>

Creates an Expect for the property LocalDate.dayOfMonth of the subject of this expectation, so that further fluent calls are assertions about it.

val Expect<ZonedDateTime>.day: Expect<Int>

Creates an Expect for the property ZonedDateTime.dayOfMonth of the subject of this expectation, so that further fluent calls are assertions about it.

dayOfWeek

val Expect<LocalDateTime>.dayOfWeek: Expect<DayOfWeek>

Creates an Expect for the property LocalDateTime.dayOfWeek of the subject of this expectation, so that further fluent calls are assertions about it.

val Expect<LocalDate>.dayOfWeek: Expect<DayOfWeek>

Creates an Expect for the property LocalDate.getDayOfWeek of the subject of this expectation, so that further fluent calls are assertions about it.

val Expect<ZonedDateTime>.dayOfWeek: Expect<DayOfWeek>

Creates an Expect for the property ZonedDatetime.dayOfWeek of the subject of this expectation, so that further fluent calls are assertions about it.

extension

val <T : Path> Expect<T>.extension: Expect<String>

Creates an Expect for the property Path.extension (provided via niok) of the subject of this expectation, so that further fluent calls are assertions about it.

fileName

val <T : Path> Expect<T>.fileName: Expect<String>

Creates an Expect for the property Path.fileNameAsString (provided via niok) of the subject of this expectation, so that further fluent calls are assertions about it.

fileNameWithoutExtension

val <T : Path> Expect<T>.fileNameWithoutExtension: Expect<String>

Creates an Expect for the property Path.fileNameWithoutExtension (provided via niok) of the subject of this expectation, so that further fluent calls are assertions about it.

first

val <K, T : Pair<K, *>> Expect<T>.first: Expect<K>

Creates an Expect for the property Pair.first of the subject of this expectation, so that further fluent calls are assertions about it.

val <T> Expect<T>.it: Expect<T>

Inline property referring actually to this and allows writing infix assertions within an expectation-group

its

val <T> Expect<T>.its: Expect<T>

Inline property referring actually to this and allows writing infix assertions within an expectation-group

key

val <K, T : Map.Entry<K, *>> Expect<T>.key: Expect<K>

Creates an Expect for the property Map.Entry.key of the subject of this expectation, so that further fluent calls are assertions about it.

keys

val <K, T : Map<out K, *>> Expect<T>.keys: Expect<Set<K>>

Creates an Expect for the property Map.keys of the subject of this expectation, so that further fluent calls are assertions about it.

message

val <T : Throwable> Expect<T>.message: Expect<String>

Expects that the property Throwable.message of the subject of this expectation is not null, creates an Expect for it and returns it.

month

val Expect<LocalDateTime>.month: Expect<Int>

Creates an Expect for the property LocalDateTime.monthValue of the subject of this expectation, so that further fluent calls are assertions about it.

val Expect<LocalDate>.month: Expect<Int>

Creates an Expect for the property LocalDate.monthValue of the subject of this expectation, so that further fluent calls are assertions about it.

val Expect<ZonedDateTime>.month: Expect<Int>

Creates an Expect for the property ZonedDateTime.monthValue of the subject of this expectation, so that further fluent calls are assertions about it.

parent

val <T : Path> Expect<T>.parent: Expect<Path>

Expects that this Path has a parent and creates an Expect for it, so that further fluent calls are assertions about it.

second

val <V, T : Pair<*, V>> Expect<T>.second: Expect<V>

Creates an Expect for the property Pair.second of the subject of this expectation, so that further fluent calls are assertions about it.

size

val <T : Collection<*>> Expect<T>.size: Expect<Int>

val <T : Map<*, *>> Expect<T>.size: Expect<Int>

Creates an Expect for the property Collection.size of the subject of this expectation, so that further fluent calls are assertions about it.

value

val <V, T : Map.Entry<*, V>> Expect<T>.value: Expect<V>

Creates an Expect for the property Map.Entry.value of the subject of this expectation, so that further fluent calls are assertions about it.

values

val <V, T : Map<*, V>> Expect<T>.values: Expect<Collection<V>>

Creates an Expect for the property Map.values of the subject of this expectation, so that further fluent calls are assertions about it.

year

val Expect<LocalDateTime>.year: Expect<Int>

Creates an Expect for the property LocalDateTime.year[LocalDateTime.getYear of the subject of this expectation, so that further fluent calls are assertions about it.

val Expect<LocalDate>.year: Expect<Int>

Creates an Expect for the property LocalDate.year of the subject of this expectation, so that further fluent calls are assertions about it.

val Expect<ZonedDateTime>.year: Expect<Int>

Creates an Expect for the property ZonedDateTime.year of the subject of this expectation, so that further fluent calls are assertions about it.

Functions

all

fun <T> all(t: T, vararg ts: T): All<T>

Helper function to create an All based on the given t and ts -- allows expressing T, vararg T.

and

infix inline fun <T> Expect<T>.and(o: o): Expect<T>

Can be used to separate single assertions.

infix fun <T> Expect<T>.and(assertionCreator: Expect<T>.() -> Unit): Expect<T>

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

infix fun <E, T : IterableLike> 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 to contain in order IterableLike expectation.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>.and(only: only): MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>

Defines that the constraint "only the specified entries exist in the MapLike" shall be applied to this sophisticated to contain in order MapLike expectation.

asEntries

infix fun <K, V, T : Map<out K, V>> Expect<T>.asEntries(o: o): Expect<Set<Map.Entry<K, V>>>

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

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

Turns Expect<Map<K, V>> into Expect<Set<Map.Entry<K, V>>> and expects that it holds all assertions the given assertionCreator creates for it.

asIterable

infix fun <E, T : Sequence<E>> Expect<T>.asIterable(o: o): Expect<Iterable<E>>

Turns Expect<E, T : Sequence<E>> into Expect<Iterable<E>>.

infix fun <E, T : Sequence<E>> Expect<T>.asIterable(assertionCreator: Expect<Iterable<E>>.() -> Unit): Expect<T>

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as Iterable.

asList

infix fun <E, T : Iterable<E>> Expect<T>.asList(o: o): Expect<List<E>>

Turns Expect<E, T : Iterable<E>> into Expect<List<E>.

infix fun <E, T : Iterable<E>> Expect<T>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<T>

infix fun <E, T : Sequence<E>> Expect<T>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<T>

@JvmName(name = "boolArrAsList")

infix fun Expect<BooleanArray>.asList(assertionCreator: Expect<List<Boolean>>.() -> Unit): Expect<BooleanArray>

@JvmName(name = "byteArrAsList")

infix fun Expect<ByteArray>.asList(assertionCreator: Expect<List<Byte>>.() -> Unit): Expect<ByteArray>

@JvmName(name = "charArrAsList")

infix fun Expect<CharArray>.asList(assertionCreator: Expect<List<Char>>.() -> Unit): Expect<CharArray>

@JvmName(name = "doubleArrAsList")

infix fun Expect<DoubleArray>.asList(assertionCreator: Expect<List<Double>>.() -> Unit): Expect<DoubleArray>

@JvmName(name = "floatArrAsList")

infix fun Expect<FloatArray>.asList(assertionCreator: Expect<List<Float>>.() -> Unit): Expect<FloatArray>

@JvmName(name = "intArrAsList")

infix fun Expect<IntArray>.asList(assertionCreator: Expect<List<Int>>.() -> Unit): Expect<IntArray>

@JvmName(name = "longArrAsList")

infix fun Expect<LongArray>.asList(assertionCreator: Expect<List<Long>>.() -> Unit): Expect<LongArray>

@JvmName(name = "shortArrAsList")

infix fun Expect<ShortArray>.asList(assertionCreator: Expect<List<Short>>.() -> Unit): Expect<ShortArray>

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

infix fun <E, T : Sequence<E>> Expect<T>.asList(o: o): Expect<List<E>>

Turns Expect<E, T : Sequence<E>> into Expect<List<E>.

infix fun <E> Expect<out Array<out E>>.asList(o: o): Expect<List<E>>

Turns Expect<Array<E>> into Expect<List<E>>.

infix fun <E> Expect<Array<E>>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<Array<E>>

@JvmName(name = "asListEOut")

infix fun <E> Expect<Array<out E>>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<Array<out E>>

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as List.

@JvmName(name = "boolArrAsList")

infix fun Expect<BooleanArray>.asList(o: o): Expect<List<Boolean>>

Turns Expect<BooleanArray> into Expect<List<Boolean>>.

@JvmName(name = "byteArrAsList")

infix fun Expect<ByteArray>.asList(o: o): Expect<List<Byte>>

Turns Expect<CharArray> into Expect<List<Byte>>.

@JvmName(name = "charArrAsList")

infix fun Expect<CharArray>.asList(o: o): Expect<List<Char>>

Turns Expect<CharArray> into Expect<List<Char>>.

@JvmName(name = "doubleArrAsList")

infix fun Expect<DoubleArray>.asList(o: o): Expect<List<Double>>

Turns Expect<DoubleArray> into Expect<List<Double>>.

@JvmName(name = "floatArrAsList")

infix fun Expect<FloatArray>.asList(o: o): Expect<List<Float>>

Turns Expect<FloatArray> into Expect<List<Float>>.

@JvmName(name = "intArrAsList")

infix fun Expect<IntArray>.asList(o: o): Expect<List<Int>>

Turns Expect<IntArray> into Expect<List<Int>>.

@JvmName(name = "longArrAsList")

infix fun Expect<LongArray>.asList(o: o): Expect<List<Long>>

Turns Expect<LongArray> into Expect<List<Double>>.

@JvmName(name = "shortArrAsList")

infix fun Expect<ShortArray>.asList(o: o): Expect<List<Short>>

Turns Expect<ShortArray> into Expect<List<Short>>.

asLocalDate

infix fun <T : Date> Expect<T>.asLocalDate(o: o): Expect<LocalDate>

Turns Expect<Date> into Expect<LocalDate>.

infix fun <T : Date> Expect<T>.asLocalDate(assertionCreator: Expect<LocalDate>.() -> Unit): Expect<T>

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as LocalDate.

asLocalDateTime

infix fun <T : Date> Expect<T>.asLocalDateTime(o: o): Expect<LocalDateTime>

Turns Expect<Date> into Expect<LocalDateTime>.

infix fun <T : Date> Expect<T>.asLocalDateTime(assertionCreator: Expect<LocalDateTime>.() -> Unit): Expect<T>

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as LocalDateTime.

asPath

infix fun <T : File> Expect<T>.asPath(o: o): Expect<Path>

Turns Expect<File> into Expect<Path>.

infix fun <T : File> Expect<T>.asPath(assertionCreator: Expect<Path>.() -> Unit): Expect<T>

Expects that the subject of this expectation holds all assertions the given assertionCreator creates for the subject as Path.

aSuccess

fun <E> aSuccess(assertionCreator: Expect<E>.() -> Unit): SuccessWithCreator<E>

Helper function to create a SuccessWithCreator based on the given assertionCreator.

atLeast

infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atLeast(times: Int): AtLeastCheckerStep<T, S>

Restricts a contains assertion by specifying that the number of occurrences of the value which we are looking for occurs at least number of times within the search input.

infix fun <E, T : IterableLike, 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

infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atMost(times: Int): AtMostCheckerStep<T, S>

Restricts a contains assertion by specifying that the number of occurrences of the value which we are looking for occurs at least once but at most number of times within the search input.

infix fun <E, T : IterableLike, 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.

because

infix fun <T> Expect<T>.because(keyWithCreator: KeyWithCreator<String, T>): Expect<T>

Allows to state a reason for one or multiple assertions for the current subject.

but

infix fun <E, T : IterableLike> 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 to contain in IterableLike expectation.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.but(only: only): MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>

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

butAtMost

infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerStep<T, S>.butAtMost(times: Int): ButAtMostCheckerStep<T, S>

Restricts a contains at least assertion by specifying that the number of occurrences of the value which we are looking for occurs at most number of times within the search input.

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

cause

inline fun <TExpected : Throwable> Expect<out Throwable>.cause(): Expect<TExpected>

Expects that the property Throwable.cause of the subject is a TExpected (the same type or a sub-type), creates an Expect of the TExpected type for it and returns it.

infix inline fun <TExpected : Throwable> Expect<out Throwable>.cause(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>

Expects that the property Throwable.cause of the subject is a TExpected (the same type or a sub-type) and holds all assertions the given assertionCreator creates for it.

day

infix fun Expect<LocalDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>

Expects that the property LocalDateTime.dayOfMonth of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

infix fun Expect<LocalDate>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>

Expects that the property LocalDate.dayOfMonth of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

infix fun Expect<ZonedDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>

Expects that the property ZonedDateTime.dayOfMonth of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

dayOfWeek

infix fun Expect<LocalDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDateTime>

Expects that the property LocalDateTime.dayOfWeekof the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

infix fun Expect<LocalDate>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDate>

Expects that the property LocalDate.getDayOfWeek of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

infix fun Expect<ZonedDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<ZonedDateTime>

Expects that the property ZonedDatetime.dayOfWeek of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

directoryEntries

fun directoryEntries(entry: String, vararg otherEntries: String): DirectoryEntries

Helper function for has to create DirectoryEntries with the provided entry and the otherEntries.

elementsOf

fun <T : IterableLike> elementsOf(iterableLike: T, reportOptionsInAnyOrderOnly: InAnyOrderOnlyReportingOptions.() -> Unit): WithInAnyOrderOnlyReportingOptions<T>

Helper function to create a WithInAnyOrderOnlyReportingOptions wrapping an IterableLike based on the given iterableLike and the given reportOptionsInAnyOrderOnly-configuration-lambda.

fun <T : IterableLike> elementsOf(iterableLike: T, reportOptionsInOrderOnly: InOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<T>

Helper function to create a WithInOrderOnlyReportingOptions wrapping an IterableLike based on the given iterableLike and the given reportOptionsInOrderOnly-configuration-lambda.

elementsOf

@JvmName(name = "elementsOfIgnoringCase")

infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>

@JvmName(name = "elementsOfIgnoringCase")

infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>

Finishes the specification of the sophisticated to contain expectation where all elements of the expectedIterableLike shall be searched (ignoring case), using a non-disjoint search.

infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>

Finishes the specification of the sophisticated to contain expectation where all elements of the expectedIterableLike shall be searched, using a non-disjoint search.

infix inline fun <E, T : IterableLike> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (an IterableLike) needs to contain all elements of the expectedIterableLike where it does not matter in which order they appear.

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

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

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

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

entries

fun <K, V : Any> entries(keyValue: KeyWithValueCreator<K, V>, vararg otherKeyValues: KeyWithValueCreator<K, V>): KeyValues<K, V>

fun <K, V : Any> entries(keyValue: KeyWithValueCreator<K, V>, vararg otherKeyValues: KeyWithValueCreator<K, V>, reportOptionsInOrderOnly: InOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<KeyValues<K, V>>

Helper function to create a KeyValues based on the given keyValue and otherKeyValues -- allows expressing Pair<K, (Expect<V>.() -> Unit)?>, vararg Pair<K, (Expect<V>.() -> Unit)?>.

fun <T : Any> entries(assertionCreatorOrNull: Expect<T>.() -> Unit?, vararg otherAssertionCreatorsOrNulls: Expect<T>.() -> Unit?): Entries<T>

Helper function to create an Entries based on the given assertionCreatorOrNull and otherAssertionCreatorsOrNulls -- allows expressing { }, vararg { }.

fun <T : Any> entries(assertionCreatorOrNull: Expect<T>.() -> Unit?, vararg otherAssertionCreatorsOrNulls: Expect<T>.() -> Unit?, reportOptionsInAnyOrderOnly: InAnyOrderOnlyReportingOptions.() -> Unit): WithInAnyOrderOnlyReportingOptions<Entries<T>>

Helper function to create a WithInAnyOrderOnlyReportingOptions wrapping an Entries based on the given assertionCreatorOrNull and otherAssertionCreatorsOrNulls as well as the given reportOptionsInAnyOrderOnly-configuration-lambda -- allows expressing { }, vararg { }, reportOptionsInAnyOrderOnly = { ... }.

fun <T : Any> entries(assertionCreatorOrNull: Expect<T>.() -> Unit?, vararg otherAssertionCreatorsOrNulls: Expect<T>.() -> Unit?, reportOptionsInOrderOnly: InOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<Entries<T>>

Helper function to create a WithInOrderOnlyReportingOptions wrapping an Entries based on the given assertionCreatorOrNull and otherAssertionCreatorsOrNulls as well as the given reportOptionsInOrderOnly-configuration-lambda -- allows expressing { }, vararg { }, reportOptionsInOrderOnly = { ... }.

entriesOf

fun <T : MapLike> entriesOf(mapLike: T, reportOptionsInOrderOnly: InOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<T>

Helper function to create a WithInOrderOnlyReportingOptions wrapping an MapLike based on the given mapLike and the given reportOptionsInOrderOnly-configuration-lambda.

entriesOf

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only and all entries of the given expectedMapLike where it does not matter in which order they appear.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain all entries of the given expectedMapLike where it does not matter in which order they appear.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only and all entries of the given expectedMapLike in the specified order.

entry

fun <T : Any> entry(assertionCreatorOrNull: Expect<T>.() -> Unit?): Entry<T>

Helper function to create an Entry based on the given assertionCreatorOrNull.

entry

infix fun <E : Any, T : IterableLike> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: Expect<E>.() -> Unit?): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (an IterableLike) needs to contain an entry which either holds all assertions assertionCreatorOrNull creates or needs to be null in case assertionCreatorOrNull is defined as null.

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

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

Finishes the specification of the sophisticated to contain expectation 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.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain exactly one entry where key and value have to equal the given keyValuePair.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain the given keyValuePair.

infix inline fun <K, V : Any, T : MapLike> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.entry(keyValue: KeyWithValueCreator<K, V>): Expect<T>

infix inline fun <K, V : Any, T : MapLike> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.entry(keyValue: KeyWithValueCreator<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain exactly one entry with a key as defined by keyValue's KeyWithValueCreator.key and a corresponding value which either holds all assertions keyValue's KeyWithValueCreator.valueAssertionCreatorOrNull creates or needs to be null in case KeyWithValueCreator.valueAssertionCreatorOrNull is defined as null.

infix inline fun <K, V : Any, T : MapLike> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.entry(keyValue: KeyWithValueCreator<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain an entry with a key as defined by keyValue's KeyWithValueCreator.key and a corresponding value which either holds all assertions keyValue's KeyWithValueCreator.valueAssertionCreatorOrNull creates or needs to be null in case KeyWithValueCreator.valueAssertionCreatorOrNull is defined as null.

exactly

infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.exactly(times: Int): ExactlyCheckerStep<T, S>

Restricts a contains assertion by specifying that the number of occurrences of the value which we are looking for occurs exactly number of times within the search input.

infix fun <E, T : IterableLike, 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.

extension

infix fun <T : Path> Expect<T>.extension(assertionCreator: Expect<String>.() -> Unit): Expect<T>

Expects that the property Path.extension (provided via niok) of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

fun <T, R> MetaFeatureOption<T>.f(description: String, provider: R): MetaFeature<R>

Creates a MetaFeature using the given provider and description.

feature

fun <T, R> feature(extractor: T.() -> R, assertionCreator: Expect<R>.() -> Unit): ExtractorWithCreator<T, R>

Helper function to create an ExtractorWithCreator

feature

infix fun <T, R> Expect<T>.feature(of: FeatureWithCreator<T, R>): Expect<T>

Extracts a feature out of the current subject of this expectation using the given FeatureWithCreator.extractor, creates a new Expect for it, applies an expectation-group based on the given FeatureWithCreator.assertionCreator for the feature and returns the initial Expect with the current subject.

infix fun <T, R> Expect<T>.feature(of: Feature<T, R>): FeatureExpect<T, R>

Extracts a feature out of the current subject of this expectation using the given Feature.extractor, creates a new Expect for it and returns it so that subsequent calls are based on the feature.

infix fun <T, R> Expect<T>.feature(of: MetaFeatureOptionWithCreator<T, R>): Expect<T>

Extracts a feature out of the current subject of this expectation, based on the given MetaFeatureOptionWithCreator creates a new Expect for it, applies an expectation-group based on the given MetaFeatureOptionWithCreator.assertionCreator for the feature and returns the initial Expect with the current subject.

infix fun <T, R> Expect<T>.feature(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>): FeatureExpect<T, R>

Extracts a feature out of the current subject of this expectation, based on the given provider, creates a new Expect for it and returns it so that subsequent calls are based on the feature.

infix fun <T, R> Expect<T>.feature(f: (T) -> R): FeatureExpect<T, R>

Extracts the value which is returned when calling the method f on the current subject of this expectation, creates a new Expect for it and returns it so that subsequent calls are based on the feature.

infix fun <T, R> Expect<T>.feature(property: KProperty1<in T, R>): FeatureExpect<T, R>

Extracts the property out of the current subject of this expectation, creates a new Expect for it and returns it so that subsequent calls are based on the feature.

fileName

infix fun <T : Path> Expect<T>.fileName(assertionCreator: Expect<String>.() -> Unit): Expect<T>

Expects that the property Path.fileNameAsString (provided via niok) of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

fileNameWithoutExtension

infix fun <T : Path> Expect<T>.fileNameWithoutExtension(assertionCreator: Expect<String>.() -> Unit): Expect<T>

Expects that the property Path.fileNameWithoutExtension (provided via niok) of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

first

infix fun <K, V, T : Pair<K, V>> Expect<T>.first(assertionCreator: Expect<K>.() -> Unit): Expect<T>

Expects that the property Pair.first of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

get

infix fun <E, T : List<E>> Expect<T>.get(index: IndexWithCreator<E>): Expect<T>

Expects that the given index is within the bounds of the subject of this expectation (a List) and that the element at that position holds all assertions the given IndexWithCreator.assertionCreator creates for it.

infix fun <E, T : List<E>> Expect<T>.get(index: Int): Expect<E>

Expects that the given index is within the bounds of the subject of this expectation (a List) and returns an Expect for the element at that position.

getExisting

infix fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: K): Expect<V>

Expects that the subject of this expectation (a Map) contains the given key, creates an Expect for the corresponding value and returns the newly created Expect, so that further fluent calls are expectations about it.

infix fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: KeyWithCreator<K, V>): Expect<T>

Expects that the subject of this expectation (a Map) contains the given key and that the corresponding value holds all assertions the given KeyWithCreator.assertionCreator creates for it.

group

fun ExpectGrouping.group(description: String, representationProvider: () -> Any? = Text.EMPTY_PROVIDER, groupingActions: ExpectGrouping.() -> Unit): ExpectGrouping

Creates and appends a group based on the given description (optionally representationProvider) and groupingActions and returns an ExpectGrouping.

fun <T> Expect<T>.group(description: String, representationProvider: () -> Any? = Text.EMPTY_PROVIDER, assertionCreator: Expect<T>.() -> Unit): Expect<T>

Creates and appends a group based on the given description (optionally representationProvider) and assertionCreator and returns an Expect.

grouped

infix fun <E, T : IterableLike> 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.

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.

infix fun <T : CharSequence> NotCheckerStep<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerStep<T, IgnoringCaseSearchBehaviour>

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

inAny

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

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

Finishes the specification of the sophisticated to contain expectation 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, T : IterableLike> 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 to contain in IterableLike expectation.

@JvmName(name = "inAnyOrderEntries")

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

@JvmName(name = "inAnyOrderEntries")

infix fun <E : Any, T : IterableLike> 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 to contain expectation 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 <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inAny(order: order): MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>

Defines that the search behaviour "find entries in any order in the MapLike" shall be applied to this sophisticated to contain in MapLike expectation.

index

fun <E> index(index: Int, assertionCreator: Expect<E>.() -> Unit): IndexWithCreator<E>

Helper function to create an IndexWithCreator based on the given index and assertionCreator.

inGiven

infix fun <E, T : IterableLike> 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 to contain in IterableLike expectation.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inGiven(order: order): MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>

Defines that the search behaviour "find entries in order in the MapLike" shall be applied to this sophisticated to contain in MapLike expectation.

its

infix fun <T, R> Expect<T>.its(extractorWithCreator: ExtractorWithCreator<T, R>): Expect<T>

Extracts a feature out of the current subject of this expectation with the help of the given extractorWithCreator.extractor, creates a new Expect for it, applies an expectation-group based on the given extractorWithCreator.assertionCreator for the feature and returns the initial Expect with the current subject.

infix fun <T, R> Expect<T>.its(extractor: T.() -> R): FeatureExpect<T, R>

Extracts a feature out of the current subject of this expectation with the help of the given extractor, creates a new Expect for it and returns it so that subsequent calls are based on the feature.

key

fun <K, V> key(key: K, assertionCreator: Expect<V>.() -> Unit): KeyWithCreator<K, V>

Helper function to create an KeyWithCreator based on the given key and assertionCreator.

key

infix fun <K, V, T : Map.Entry<K, V>> Expect<T>.key(assertionCreator: Expect<K>.() -> Unit): Expect<T>

Expects that the property Map.Entry.key of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

keys

infix fun <K, V, T : Map<out K, V>> Expect<T>.keys(assertionCreator: Expect<Set<K>>.() -> Unit): Expect<T>

Expects that the property Map.keys of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

keyValue

fun <K, V : Any> keyValue(key: K, valueAssertionCreatorOrNull: Expect<V>.() -> Unit?): KeyWithValueCreator<K, V>

Helper function to create a KeyWithValueCreator based on the given key and valueAssertionCreatorOrNull -- allows expressing Pair<K, (Expect<V>.() -> Unit)?>.

keyValues

fun <K, V : Any> ~~keyValues~~(keyValue: KeyWithValueCreator<K, V>, vararg otherKeyValues: KeyWithValueCreator<K, V>): KeyValues<K, V>

fun <K, V : Any> ~~keyValues~~(keyValue: KeyWithValueCreator<K, V>, vararg otherKeyValues: KeyWithValueCreator<K, V>, reportOptionsInOrderOnly: InOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<KeyValues<K, V>>

Helper function to create a KeyValues based on the given keyValue and otherKeyValues -- allows expressing Pair<K, (Expect<V>.() -> Unit)?>, vararg Pair<K, (Expect<V>.() -> Unit)?>.

matchFor

infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.matchFor(patterns: All<Regex>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the given Regex are expected to have a match, using a non-disjoint search.

infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.matchFor(pattern: Regex): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the given Regex is expected to have a match.

max

infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(o: o): Expect<E>

Creates an Expect for the result of calling max() on the subject of this expectation, so that further fluent calls are assertions about it.

infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(assertionCreator: Expect<E>.() -> Unit): Expect<T>

Expects that the result of calling max() on the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

message

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

Expects that the property Throwable.message of the subject of this expectation is not null and holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

messageToContain

infix fun <T : Throwable> Expect<T>.messageToContain(values: Values<Any>): Expect<T>

Expects that the property Throwable.message of the subject of this expectation is not null and contains values's toString representation using a non-disjoint search.

infix fun <T : Throwable> Expect<T>.messageToContain(expected: CharSequenceOrNumberOrChar): Expect<T>

Expects that the property Throwable.message of the subject of this expectation is not null and contains expected's toString representation using a non-disjoint search.

min

infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(o: o): Expect<E>

Creates an Expect for the result of calling min() on the subject of this expectation, so that further fluent calls are assertions about it.

infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(assertionCreator: Expect<E>.() -> Unit): Expect<T>

Expects that the result of calling min() on the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

month

infix fun Expect<LocalDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>

Expects that the property LocalDateTime.monthValueof the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

infix fun Expect<LocalDate>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>

Expects that the property LocalDate.monthValue of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

infix fun Expect<ZonedDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>

Expects that the property ZonedDateTime.monthValue of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

notOrAtMost

infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<T, S>

Restricts a contains assertion by specifying that the number of occurrences of the value which we are looking for occurs not at all or at most number of times within the search input.

infix fun <E, T : IterableLike, 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.

notToBe

infix fun <T : CharSequence> Expect<T>.notToBe(blank: blank): Expect<T>

Expects that the subject of this expectation (a CharSequence) CharSequence.kotlin.text.isNotBlank.

infix fun <T : CharSequence> Expect<T>.notToBe(empty: empty): Expect<T>

Expects that the subject of this expectation (a CharSequence) CharSequence.kotlin.text.isNotEmpty.

infix fun <T : Collection<*>> Expect<T>.notToBe(empty: empty): Expect<T>

Expects that the subject of this expectation (a Collection) is not an empty Collection.

infix fun <T : Map<*, *>> Expect<T>.notToBe(empty: empty): Expect<T>

Expects that the subject of this expectation (a Map) is not an empty Map.

infix fun <T : Path> Expect<T>.notToBe(executable: executable): Expect<T>

Expects that the subject of this expectation (a Path) is not executable; meaning that there is a file system entry at the location the Path points to and that the current thread does not have the permission to execute it.

infix fun <T : Path> Expect<T>.notToBe(existing: existing): Expect<T>

Expects that the subject of this expectation (a Path) does not exist; meaning that there is no file system entry at the location the Path points to.

infix fun <T : Path> Expect<T>.notToBe(readable: readable): Expect<T>

Expects that the subject of this expectation (a Path) is not readable; meaning that there is a file system entry at the location the Path points to and that the current thread does not have the permission to read from it.

infix fun <T : Path> Expect<T>.notToBe(writable: writable): Expect<T>

Expects that the subject of this expectation (a Path) is not writable; meaning that there is a file system entry at the location the Path points to and that the current thread does not have the permission to write from it.

notToBeAnInstanceOf

inline fun <TNotExpected : Any> Expect<*>.notToBeAnInstanceOf(): Expect<*>

Expects that the subject of this expectation is not a TNotExpected (the same type or a sub-type).

infix fun <T> Expect<T>.notToBeAnInstanceOf(types: Types): Expect<T>

Expects that the subject of this expectation is not one of the given types (the same type or a sub-type).

infix fun <T> Expect<T>.notToBeAnInstanceOf(type: KClass<*>): Expect<T>

Expects that the subject of this expectation is not one of the given types (the same type or a sub-type).

notToBeGreaterThan

infix fun <T : Comparable<T>> Expect<T>.notToBeGreaterThan(expected: T): Expect<T>

Expects that the subject of this expectation is less than or equal expected. The comparison is carried out with Comparable.compareTo.

infix fun <T : ChronoZonedDateTime<T>> Expect<T>.~~notToBeGreaterThan~~(expected: T): Nothing

Deprecated overload which shall give a hint to the user/guide the user to use toBeBeforeOrTheSamePointInTimeAs instead.

notToBeLessThan

infix fun <T : Comparable<T>> Expect<T>.notToBeLessThan(expected: T): Expect<T>

Expects that the subject of this expectation is not less than expected. The comparison is carried out with Comparable.compareTo.

infix fun <T : ChronoZonedDateTime<T>> Expect<T>.~~notToBeLessThan~~(expected: T): Nothing

Deprecated overload which shall give a hint to the user/guide the user to use toBeAfterOrTheSamePointInTimeAs instead.

notToBeTheInstance

infix fun <T> Expect<T>.notToBeTheInstance(expected: T): Expect<T>

Expects that the subject of this expectation is not the same instance as expected.

notToContain

infix fun <T : CharSequence> Expect<T>.notToContain(values: Values<CharSequenceOrNumberOrChar>): Expect<T>

Expects that the subject of this expectation (a CharSequence) does not contain the toString representation of the given values.

infix fun <T : CharSequence> Expect<T>.notToContain(o: o): NotCheckerStep<T, NotSearchBehaviour>

Starts a sophisticated toContain assertion building process based on this Expect and already chooses a NotCheckerStep.

infix fun <T : CharSequence> Expect<T>.notToContain(expected: CharSequenceOrNumberOrChar): Expect<T>

Expects that the subject of this expectation (a CharSequence) does not contain expected's toString representation.

infix fun <E, T : Iterable<E>> Expect<T>.notToContain(expected: E): Expect<T>

Expects that the subject of this expectation (an Iterable) has at least one element and that it does not contain the expected value.

infix fun <E, T : Iterable<E>> Expect<T>.notToContain(values: Values<E>): Expect<T>

Expects that the subject of this expectation (an Iterable) has at least one element and that it does not contain the expected values.

infix fun <E, T : Iterable<E>> Expect<T>.notToContain(o: o): NotCheckerStep<E, T, NotSearchBehaviour>

Starts a sophisticated toContain assertion building process based on this Expect and already chooses a NotCheckerStep.

notToContainKey

infix fun <K, T : Map<out K, *>> Expect<T>.notToContainKey(key: K): Expect<T>

Expects that the subject of this expectation (a Map) does not contain the given key.

notToEndWith

infix fun <T : CharSequence> Expect<T>.notToEndWith(expected: CharSequence): Expect<T>

Expects that the subject of this expectation (a CharSequence) does not end with expected.

infix fun <T : Path> Expect<T>.notToEndWith(expected: Path): Expect<T>

Expects that the subject of this expectation (a Path) does not end with the expected Path;

notToEqual

infix fun <T> Expect<T>.notToEqual(expected: T): Expect<T>

Expects that the subject of this expectation is not (equal to) expected.

infix fun <T : BigDecimal?> Expect<T>.~~notToEqual~~(expected: T): Nothing

Deprecated as it would compare the subject against expected including scale -- many developers are not aware of that.

@JvmName(name = "notToEqualNull")

infix fun <T : BigDecimal> Expect<T?>.notToEqual(expected: Nothing?): Expect<T>

Expects that the subject of this expectation (a BigDecimal) is not null.

notToEqualIncludingScale

infix fun <T : BigDecimal> Expect<T>.notToEqualIncludingScale(expected: T): Expect<T>

Expects that the subject of this expectation (a BigDecimal) is not equal to expected including BigDecimal.scale.

notToEqualNull

infix inline fun <T : Any> Expect<T?>.notToEqualNull(o: o): Expect<T>

Expects that the subject of this expectation is not null and changes the subject to the non-nullable version.

infix inline fun <T : Any> Expect<T?>.notToEqualNull(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>

Expects that the subject of this expectation is not null and that it holds all assertions the given assertionCreator creates.

notToEqualNumerically

infix fun <T : BigDecimal> Expect<T>.notToEqualNumerically(expected: T): Expect<T>

Expects that the subject of this expectation (a BigDecimal) is not numerically equal to expected.

notToEqualOneIn

infix fun <T> Expect<T>.notToEqualOneIn(expected: IterableLike): Expect<T>

Expects that the subject of this expectation is not equal to any value of expected.

notToEqualOneOf

infix fun <T> Expect<T>.notToEqualOneOf(values: Values<T>): Expect<T>

Expects that the subject of this expectation is not equal to any value of values.

notToHave

infix fun <E, T : Iterable<E>> Expect<T>.notToHave(elements: elements): Expect<T>

Expects that the subject of this expectation (an Iterable) does not have next element.

infix fun <T : Iterator<*>> Expect<T>.notToHave(next: next): Expect<T>

Expects that the subject of this expectation (an Iterator) does not have next element.

notToHaveElementsOrAll

infix fun <E : Any, T : Iterable<E?>> Expect<T>.notToHaveElementsOrAll(assertionCreatorOrNull: Expect<E>.() -> Unit?): Expect<T>

Expects that the subject of this expectation (an Iterable) either has no next element or

notToHaveElementsOrAny

infix fun <E : Any, T : Iterable<E?>> Expect<T>.notToHaveElementsOrAny(assertionCreatorOrNull: Expect<E>.() -> Unit?): Expect<T>

Expects that the subject of this expectation (an Iterable) either has no next element or

notToHaveElementsOrNone

infix fun <E : Any, T : Iterable<E?>> Expect<T>.notToHaveElementsOrNone(assertionCreatorOrNull: Expect<E>.() -> Unit?): Expect<T>

Expects that the subject of this expectation (an Iterable) either has no next element or

notToMatch

infix fun <T : CharSequence> Expect<T>.notToMatch(pattern: Regex): Expect<T>

Expects that the subject of this expectation (a CharSequence) mismatches the given Regex.

notToStartWith

infix fun <T : CharSequence> Expect<T>.notToStartWith(expected: CharSequence): Expect<T>

Expects that the subject of this expectation (a CharSequence) does not start with expected.

infix fun <T : Path> Expect<T>.notToStartWith(expected: Path): Expect<T>

Expects that the subject of this expectation (a Path) does not start with the expected.

notToThrow

fun <R, T : () -> R> Expect<T>.notToThrow(): Expect<R>

Expects that no Throwable is thrown at all when calling the subject (a lambda with arity 0, i.e. without arguments) and changes the subject of this expectation to the return value of type R.

infix fun <R, T : () -> R> Expect<T>.notToThrow(assertionCreator: Expect<R>.() -> Unit): Expect<R>

Expects that no Throwable is thrown at all when calling the subject (a lambda with arity 0, i.e. without arguments) and that the corresponding return value holds all assertions the given assertionCreator creates.

fun <T, R> of(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>, assertionCreator: Expect<R>.() -> Unit): MetaFeatureOptionWithCreator<T, R>

Helper function to create a MetaFeatureOptionWithCreator based on a lambda with MetaFeatureOption receiver (has to return a MetaFeature) and an assertionCreator.

fun <T, R> of(description: String, extractor: T.() -> R): Feature<T, R>

fun <T, R> of(description: String, extractor: T.() -> R, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>

Creates a Feature using the given extractor and description.

fun <T> of(reason: String, assertionCreator: Expect<T>.() -> Unit): KeyWithCreator<String, T>

Helper function to create a KeyWithCreator based on the given reason and assertionCreator.

fun <T, R> of(f: (T) -> R, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>

Helper function to create a FeatureWithCreator based on a KFunction1 + assertionCreator.

fun <T, A1, R> of(f: (T, A1) -> R, a1: A1): Feature<T, R>

Helper function to create a Feature based on a KFunction2 + arguments.

fun <T, R> of(property: KProperty1<in T, R>, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>

Helper function to create a FeatureWithCreator based on a KProperty1 + assertionCreator.

fun <T, A1, R> of(f: (T, A1) -> R, a1: A1, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>

Helper function to create a FeatureWithCreator based on a KFunction2 + arguments + assertionCreator.

fun <T, A1, A2, R> of(f: (T, A1, A2) -> R, a1: A1, a2: A2): Feature<T, R>

Helper function to create a Feature based on a KFunction3 + arguments.

fun <T, A1, A2, R> of(f: (T, A1, A2) -> R, a1: A1, a2: A2, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>

Helper function to create a FeatureWithCreator based on a KFunction3 + arguments + assertionCreator.

fun <T, A1, A2, A3, R> of(f: (T, A1, A2, A3) -> R, a1: A1, a2: A2, a3: A3): Feature<T, R>

Helper function to create a Feature based on a KFunction4 + arguments.

fun <T, A1, A2, A3, R> of(f: (T, A1, A2, A3) -> R, a1: A1, a2: A2, a3: A3, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>

Helper function to create a FeatureWithCreator based on a KFunction4 + arguments + assertionCreator.

fun <T, A1, A2, A3, A4, R> of(f: (T, A1, A2, A3, A4) -> R, a1: A1, a2: A2, a3: A3, a4: A4): Feature<T, R>

Helper function to create a Feature based on a KFunction5 + arguments.

fun <T, A1, A2, A3, A4, R> of(f: (T, A1, A2, A3, A4) -> R, a1: A1, a2: A2, a3: A3, a4: A4, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>

Helper function to create a FeatureWithCreator based on a KFunction5 + arguments + assertionCreator.

fun <T, A1, A2, A3, A4, A5, R> of(f: (T, A1, A2, A3, A4, A5) -> R, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): Feature<T, R>

Helper function to create a Feature based on a KFunction6 + arguments.

fun <T, A1, A2, A3, A4, A5, R> of(f: (T, A1, A2, A3, A4, A5) -> R, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>

Helper function to create a FeatureWithCreator based on a KFunction6 + arguments + assertionCreator.

order

fun <E> order(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): Order<E, Group<E>>

Helper function to create an Order based on the given firstGroup, secondGroup and otherExpectedGroups.

@JvmName(name = "orderWithReportInGroup")

fun <E> order(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>, reportInGroup: InAnyOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<WithInAnyOrderOnlyReportingOptions<Order<E, Group<E>>>>

Helper function to create a WithInOrderOnlyReportingOptions wrapping a WithInAnyOrderOnlyReportingOptions which wraps in turn an Order based on the given firstGroup, secondGroup and otherExpectedGroups as well as the given reportInGroup-configuration-lambda for the WithInAnyOrderOnlyReportingOptions.

fun <E> order(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>, report: InOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<WithInAnyOrderOnlyReportingOptions<Order<E, Group<E>>>>

Helper function to create a WithInOrderOnlyReportingOptions wrapping a WithInAnyOrderOnlyReportingOptions which wraps in turn an Order based on the given firstGroup, secondGroup and otherExpectedGroups as well as the given report-configuration-lambda for the WithInOrderOnlyReportingOptions.

fun <E> order(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>, report: InOrderOnlyReportingOptions.() -> Unit, reportInGroup: InAnyOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<WithInAnyOrderOnlyReportingOptions<Order<E, Group<E>>>>

Helper function to create a WithInOrderOnlyReportingOptions wrapping a WithInAnyOrderOnlyReportingOptions which wraps in turn an Order based on the given firstGroup, secondGroup and otherExpectedGroups as well as the given report-configuration-lambda for the WithInOrderOnlyReportingOptions and the reportInGroup-configuration-lambda for the WithInAnyOrderOnlyReportingOptions.

pairs

fun <K, V> pairs(pair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Pairs<K, V>

fun <K, V> pairs(pair: Pair<K, V>, vararg otherPairs: Pair<K, V>, reportOptionsInOrderOnly: InOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<Pairs<K, V>>

Helper function to create a Pairs based on the given pair and otherPairs -- allows expressing Pair<K, V>, vararg Pair<K, V>.

parent

infix fun <T : Path> Expect<T>.parent(assertionCreator: Expect<Path>.() -> Unit): Expect<T>

Expects that this Path has a parent, that the parent holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

path

fun <E> path(path: String, assertionCreator: Expect<E>.() -> Unit): PathWithCreator<E>

Helper function to create a PathWithCreator based on the given path and assertionCreator.

present

fun <E> present(assertionCreator: Expect<E>.() -> Unit): PresentWithCreator<E>

Helper function to create a PresentWithCreator based on the given assertionCreator.

regex

@JvmName(name = "regexIgnoringCase")

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

Finishes the specification of the sophisticated to contain expectation where the given regular expression pattern is expected to have a match (ignoring case), using a non-disjoint search.

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

Finishes the specification of the sophisticated to contain expectation where the given regular expression pattern is expected to have a match, using a non-disjoint search.

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

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

regexPatterns

fun regexPatterns(pattern: String, vararg otherPatterns: String): RegexPatterns

Helper function to create a RegexPatterns based on the given pattern and otherPatterns -- allows expressing String, vararg String which are treated as regex patterns.

resolve

infix fun <T : Path> Expect<T>.resolve(path: PathWithCreator<Path>): Expect<T>

Expects that PathWithCreator.path resolves against this Path, that the resolved Path holds all assertions the given PathWithCreator.assertionCreator creates for it and returns an Expect for the current subject of this expectation.

infix fun <T : Path> Expect<T>.resolve(other: String): Expect<Path>

Expects that other resolves against this Path and creates an Expect for the resolved Path so that further fluent calls are assertions about it.

second

infix fun <K, V, T : Pair<K, V>> Expect<T>.second(assertionCreator: Expect<V>.() -> Unit): Expect<T>

Expects that the property Pair.second of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

size

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

infix fun <K, V, T : Map<out K, V>> Expect<T>.size(assertionCreator: Expect<Int>.() -> Unit): Expect<T>

Expects that the property Collection.size of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

the

@JvmName(name = "regexIgnoringCase")

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

Finishes the specification of the sophisticated to contain expectation where the given regular expression patterns are expected to have a match (ignoring case), using a non-disjoint search.

@JvmName(name = "valuesIgnoringCase")

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

Finishes the specification of the sophisticated to contain expectation where the values shall be searched (ignoring case), using a non-disjoint search.

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

Finishes the specification of the sophisticated to contain expectation where the given regular expression patterns are expected to have a match, using a non-disjoint search.

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

Finishes the specification of the sophisticated to contain expectation where the given values shall be searched, using a non-disjoint search.

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

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

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

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

infix fun <E, T : IterableLike> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): Expect<T>

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

infix fun <E : Any, T : IterableLike> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (an IterableLike) needs to contain an entry for each in 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 needs to be null in case entries.assertionCreatorOrNull is defined as null.

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

@JvmName(name = "theValuesWithReportingOptions")

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

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

@JvmName(name = "theElementsOfsWithReportingOptions")

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

@JvmName(name = "theElementsOfWithReportingOptions")

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

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

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

@JvmName(name = "theValuesWithReportingOptions")

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

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

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

@JvmName(name = "theEntriesWithReportingOptions")

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

Finishes the specification of the sophisticated to contain expectation 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 : Any, T : IterableLike> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E>): Expect<T>

@JvmName(name = "theEntriesWithReportingOptions")

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

Finishes the specification of the sophisticated to contain expectation 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

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.the(pairs: Pairs<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only the given key-value pairs where it does not matter in which order they appear.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.the(pairs: Pairs<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain the given key-value pairs where it does not matter in which order they appear.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.the(pairs: Pairs<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only the given key-value pairs in the specified order.

@JvmName(name = "thePairsWithReportingOption")

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.the(pairs: WithInOrderOnlyReportingOptions<Pairs<K, V>>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only the given pairs in the specified order.

infix fun <K, V, T : MapLike> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.the(entriesOf: WithInOrderOnlyReportingOptions<MapLike>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only and all entries of the given MapLike in the specified order.

infix inline fun <K, V : Any, T : MapLike> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.the(entries: KeyValues<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only the given entries where it does not matter in which order they appear -- an entry is contained if it has a key as defined by keyValue's KeyWithValueCreator.key and a corresponding value which either holds all assertions keyValue's KeyWithValueCreator.valueAssertionCreatorOrNull creates or needs to be null in case KeyWithValueCreator.valueAssertionCreatorOrNull is defined as null.

infix inline fun <K, V : Any, T : MapLike> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.the(keyValues: KeyValues<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain the given keyValues where it does not matter in which order they appear -- an entry is contained if it has a key as defined by keyValue's KeyWithValueCreator.key and a corresponding value which either holds all assertions keyValue's KeyWithValueCreator.valueAssertionCreatorOrNull creates or needs to be null in case KeyWithValueCreator.valueAssertionCreatorOrNull is defined as null.

@JvmName(name = "theKeyValuesWithReportingOption")

infix inline fun <K, V : Any, T : MapLike> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.the(entries: WithInOrderOnlyReportingOptions<KeyValues<K, V>>): Expect<T>

infix inline fun <K, V : Any, T : MapLike> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.the(entries: KeyValues<K, V>): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the subject (a MapLike) needs to contain only the given entries in the specified order -- an entry is contained if it has a key as defined by keyValue's KeyWithValueCreator.key and a corresponding value which either holds all assertions keyValue's KeyWithValueCreator.valueAssertionCreatorOrNull creates or needs to be null in case KeyWithValueCreator.valueAssertionCreatorOrNull is defined as null.

toBe

infix fun <T : CharSequence> Expect<T>.toBe(empty: empty): Expect<T>

Expects that the subject of this expectation (a CharSequence) CharSequence.kotlin.text.isEmpty.

infix fun <E, T : Result<E>> Expect<T>.toBe(aSuccess: aSuccess): Expect<E>

Expects that the subject of this expectation (a Result) is a success (Result.isSuccess) and returns an Expect for the inner type E.

infix fun <E, T : Result<E>> Expect<T>.toBe(success: SuccessWithCreator<E>): Expect<T>

Expects that the subject of this expectation (a Result) is a success (Result.isSuccess) and that it holds all assertions the given SuccessWithCreator.assertionCreator creates.

infix fun <T : Collection<*>> Expect<T>.toBe(empty: empty): Expect<T>

Expects that the subject of this expectation (a Collection) is an empty Collection.

infix fun <T : Map<*, *>> Expect<T>.toBe(empty: empty): Expect<T>

Expects that the subject of this expectation (a Map) is an empty Map.

infix fun <T : Path> Expect<T>.toBe(aDirectory: aDirectory): Expect<T>

Expects that the subject of this expectation (a Path) is a directory; meaning that there is a file system entry at the location the Path points to and that is a directory.

infix fun <T : Path> Expect<T>.toBe(aRegularFile: aRegularFile): Expect<T>

Expects that the subject of this expectation (a Path) is a file; meaning that there is a file system entry at the location the Path points to and that is a regular file.

infix fun <T : Path> Expect<T>.toBe(aSymbolicLink: aSymbolicLink): Expect<T>

Expects that the subject of this expectation (a Path) is a symbolic link; meaning that there is a file system entry at the location the Path points to and that is a symbolic link.

infix fun <T : Path> Expect<T>.toBe(absolute: absolute): Expect<T>

Expects that the subject of this expectation (a Path) is an absolute path; meaning that the Path specified in this instance starts at the file system root.

infix fun <T : Path> Expect<T>.toBe(anEmptyDirectory: anEmptyDirectory): Expect<T>

Expects that the subject of this expectation (a Path) is an empty directory; meaning that there is a file system entry at the location the Path points to and that is an empty directory.

infix fun <T : Path> Expect<T>.toBe(executable: executable): Expect<T>

Expects that the subject of this expectation (a Path) is executable; meaning that there is a file system entry at the location the Path points to and that the current thread has the permission to execute it.

infix fun <T : Path> Expect<T>.toBe(existing: existing): Expect<T>

Expects that the subject of this expectation (a Path) exists; meaning that there is a file system entry at the location the Path points to.

infix fun <T : Path> Expect<T>.toBe(readable: readable): Expect<T>

Expects that the subject of this expectation (a Path) is readable; meaning that there is a file system entry at the location the Path points to and that the current thread has the permission to read from it.

infix fun <T : Path> Expect<T>.toBe(relative: relative): Expect<T>

Expects that the subject of this expectation (a Path) is a relative path; meaning that the Path specified in this instance does not start at the file system root.

infix fun <T : Path> Expect<T>.toBe(writable: writable): Expect<T>

Expects that the subject of this expectation (a Path) is writable; meaning that there is a file system entry at the location the Path points to and that the current thread has the permission to write to it.

infix fun <T : Optional<*>> Expect<T>.toBe(empty: empty): Expect<T>

Expects that the subject of this expectation (an Optional) is empty (not present).

infix fun <E : Any, T : Optional<E>> Expect<T>.toBe(present: PresentWithCreator<E>): Expect<T>

Expects that the subject of this expectation (an Optional) is present and that the wrapped value of type E holds all assertions the given PresentWithCreator.assertionCreator creates.

infix fun <E : Any, T : Optional<E>> Expect<T>.toBe(present: present): FeatureExpect<T, E>

Expects that the subject of this expectation (an Optional) is present and returns an Expect for the inner type E.

toBeAFailure

inline fun <TExpected : Throwable> Expect<out Result<*>>.toBeAFailure(): Expect<TExpected>

Expects that the subject of this expectation (a Result) is a failure (Result.isFailure) and that it encapsulates an exception of type TExpected.

infix inline fun <TExpected : Throwable> Expect<out Result<*>>.toBeAFailure(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>

Expects that the subject of this expectation (a Result) is a failure (Result.isFailure) , that it encapsulates an exception of type TExpected and that the exception holds all assertions the given assertionCreator creates.

toBeAfter

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeAfter(expected: ChronoLocalDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDateTime) is after the expected.

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeAfter(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDateTime) is before the expected given as String in (modified) ISO 8601 format. The string will be converted to a LocalDateTime according to ISO 8601 but with a slight deviation. The alternative notation (e.g. 20200401120001 instead of 2020-04-01T12:00:01) is not supported and we accept a date without time in which case 00:00:00 is used. Following the supported formats from the longest to the shortest: yyyy-mm-ddThh:mm:ss.sss (up to 9 digits for nanoseconds) yyyy-mm-ddThh:mm:ss yyyy-mm-ddThh:mm yyyy-mm-dd

infix fun <T : ChronoLocalDate> Expect<T>.toBeAfter(expected: ChronoLocalDate): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is after the expected.

infix fun <T : ChronoLocalDate> Expect<T>.toBeAfter(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is after the expected given as String.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeAfter(expected: ChronoZonedDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is after the expected.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeAfter(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is before or equals the expected given as String.

toBeAfterOrTheSamePointInTimeAs

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: ChronoLocalDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDateTime) is after or equal the expected.

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: String): Expect<T>

infix fun <T : ChronoLocalDate> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: ChronoLocalDate): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is after or equal the expected.

infix fun <T : ChronoLocalDate> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is after or equal the expected given as String.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: ChronoZonedDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is after or equal the expected.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeAfterOrTheSamePointInTimeAs(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is before or equals the expected given as String.

toBeAnInstanceOf

inline fun <TSub : Any> Expect<*>.toBeAnInstanceOf(): Expect<TSub>

Expects that the subject of this expectation is a TSub (the same type or a sub-type) and changes the subject to this type.

infix inline fun <TSub : Any> Expect<*>.toBeAnInstanceOf(noinline assertionCreator: Expect<TSub>.() -> Unit): Expect<TSub>

Expects that the subject of this expectation is a TSub (the same type or a sub-type) and that it holds all assertions the given assertionCreator creates.

toBeBefore

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeBefore(expected: ChronoLocalDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDateTime) is before the expected.

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeBefore(expected: String): Expect<T>

infix fun <T : ChronoLocalDate> Expect<T>.toBeBefore(expected: ChronoLocalDate): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is before the expected.

infix fun <T : ChronoLocalDate> Expect<T>.toBeBefore(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is before the expected given as String.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeBefore(expected: ChronoZonedDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is before the expected.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeBefore(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is before or equals the expected given as String.

toBeBeforeOrTheSamePointInTimeAs

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: ChronoLocalDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDateTime) is before or equal the expected.

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: String): Expect<T>

infix fun <T : ChronoLocalDate> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: ChronoLocalDate): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is before or equal the expected.

infix fun <T : ChronoLocalDate> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is before or equal the expected given as String. The expected parameter needs to be in the form of yyyy-mm-dd or else an exception will be thrown.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: ChronoZonedDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is before or equals the expected.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeBeforeOrTheSamePointInTimeAs(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is before or equals the expected given as String.

toBeEqualComparingTo

infix fun <T : Comparable<T>> Expect<T>.toBeEqualComparingTo(expected: T): Expect<T>

Expects that the subject of this expectation is equal to expected where the comparison is carried out with Comparable.compareTo.

infix fun <T : ChronoZonedDateTime<T>> Expect<T>.~~toBeEqualComparingTo~~(expected: T): Nothing

Deprecated overload which shall give a hint to the user/guide the user to use toBeTheSamePointInTimeAs instead.

toBeGreaterThan

infix fun <T : Comparable<T>> Expect<T>.toBeGreaterThan(expected: T): Expect<T>

Expects that the subject of this expectation is greater than (>) expected. The comparison is carried out with Comparable.compareTo.

infix fun <T : ChronoZonedDateTime<T>> Expect<T>.~~toBeGreaterThan~~(expected: T): Nothing

Deprecated overload which shall give a hint to the user/guide the user to use toBeAfter instead.

toBeGreaterThanOrEqualTo

infix fun <T : Comparable<T>> Expect<T>.toBeGreaterThanOrEqualTo(expected: T): Expect<T>

Expects that the subject of this expectation is greater than or equal (>=) expected. The comparison is carried out with Comparable.compareTo.

infix fun <T : ChronoZonedDateTime<T>> Expect<T>.~~toBeGreaterThanOrEqualTo~~(expected: T): Nothing

Deprecated overload which shall give a hint to the user/guide the user to use toBeAfterOrTheSamePointInTimeAs instead.

toBeLessThan

infix fun <T : Comparable<T>> Expect<T>.toBeLessThan(expected: T): Expect<T>

Expects that the subject of this expectation is less than (<) expected. The comparison is carried out with Comparable.compareTo.

infix fun <T : ChronoZonedDateTime<T>> Expect<T>.~~toBeLessThan~~(expected: T): Nothing

Deprecated overload which shall give a hint to the user/guide the user to use toBeBefore instead.

toBeLessThanOrEqualTo

infix fun <T : Comparable<T>> Expect<T>.toBeLessThanOrEqualTo(expected: T): Expect<T>

Expects that the subject of this expectation is less than or equal (<=) expected. The comparison is carried out with Comparable.compareTo.

infix fun <T : ChronoZonedDateTime<T>> Expect<T>.~~toBeLessThanOrEqualTo~~(expected: T): Nothing

Deprecated overload which shall give a hint to the user/guide the user to use toBeBeforeOrTheSamePointInTimeAs instead.

toBeTheInstance

infix fun <T> Expect<T>.toBeTheInstance(expected: T): Expect<T>

Expects that the subject of this expectation is the same instance as expected.

toBeTheSamePointInTimeAs

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeTheSamePointInTimeAs(expected: ChronoLocalDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDateTime) is equal to the expected.

infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.toBeTheSamePointInTimeAs(expected: String): Expect<T>

infix fun <T : ChronoLocalDate> Expect<T>.toBeTheSamePointInTimeAs(expected: ChronoLocalDate): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is equal to the expected.

infix fun <T : ChronoLocalDate> Expect<T>.toBeTheSamePointInTimeAs(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoLocalDate) is equal to the expected given as String.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeTheSamePointInTimeAs(expected: ChronoZonedDateTime<*>): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is equal to the expected.

infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.toBeTheSamePointInTimeAs(expected: String): Expect<T>

Expects that the subject of this expectation (a ChronoZonedDateTime) is before or equals the expected given as String.

toContain

infix fun <T : CharSequence> Expect<T>.toContain(patterns: All<Regex>): Expect<T>

Expects that the subject of this expectation (a CharSequence) contains a sequence which matches the given regular expression patterns, using a non-disjoint search.

infix fun <T : CharSequence> Expect<T>.toContain(regexPatterns: RegexPatterns): Expect<T>

Expects that the subject of this expectation (a CharSequence) contains a sequence which matches the given regular expression regexPatterns, using a non-disjoint search.

infix fun <T : CharSequence> Expect<T>.toContain(values: Values<CharSequenceOrNumberOrChar>): Expect<T>

Expects that the subject of this expectation (a CharSequence) contains the toString representation of the given values using a non-disjoint search.

infix fun <T : CharSequence> Expect<T>.toContain(o: o): CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>

infix fun <E, T : Iterable<E>> Expect<T>.toContain(o: o): IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>

infix fun <K, V, T : Map<out K, V>> Expect<T>.toContain(o: o): MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>

Starts a sophisticated toContain assertion building process based on this Expect.

infix fun <T : CharSequence> Expect<T>.toContain(expected: CharSequenceOrNumberOrChar): Expect<T>

Expects that the subject of this expectation (a CharSequence) contains the expected's toString representation.

infix fun <T : CharSequence> Expect<T>.toContain(pattern: Regex): Expect<T>

Expects that the subject of this expectation (a CharSequence) contains a sequence which matches the given regular expression pattern.

infix fun <E, T : Iterable<E>> Expect<T>.toContain(expected: E): Expect<T>

Expects that the subject of this expectation (an Iterable) contains the expected value.

infix fun <E, T : Iterable<E>> Expect<T>.toContain(values: Values<E>): Expect<T>

Expects that the subject of this expectation (an Iterable) contains the expected values.

infix fun <E : Any, T : Iterable<E?>> Expect<T>.toContain(entries: Entries<E>): Expect<T>

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

infix fun <E : Any, T : Iterable<E?>> Expect<T>.toContain(assertionCreatorOrNull: Expect<E>.() -> Unit?): Expect<T>

Expects that the subject of this expectation (an Iterable) contains an entry holding the assertions created by assertionCreatorOrNull or an entry which is null in case assertionCreatorOrNull is defined as null.

infix fun <K, V, T : Map<out K, V>> Expect<T>.toContain(pairs: Pairs<K, V>): Expect<T>

Expects the subject of this expectation (a Map) contains for each key-value pair in pairs, a key as defined by that entry's Pair.first with a corresponding value as defined by entry's Pair.second.

infix fun <K, V, T : Map<out K, V>> Expect<T>.toContain(keyValuePair: Pair<K, V>): Expect<T>

Expects that the subject of this expectation (a Map) contains a key as defined by keyValuePair's Pair.first with a corresponding value as defined by keyValuePair's Pair.second

infix inline fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContain(keyValues: KeyValues<K, V>): Expect<T>

Expects that the subject of this expectation (a Map) contains for each KeyWithValueCreator in keyValues, a key as defined by KeyWithValueCreator.key with a corresponding value which either holds all assertions KeyWithValueCreator's KeyWithValueCreator.valueAssertionCreatorOrNull creates or needs to be null in case KeyWithValueCreator.valueAssertionCreatorOrNull is defined as null

infix inline fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContain(keyValue: KeyWithValueCreator<K, V>): Expect<T>

Expects that the subject of this expectation (a Map) contains a key as defined by keyValue's KeyWithValueCreator.key with a corresponding value which either holds all assertions keyValue's KeyWithValueCreator.valueAssertionCreatorOrNull creates or needs to be null in case KeyWithValueCreator.valueAssertionCreatorOrNull is defined as null

toContainElementsOf

infix inline fun <E, T : Iterable<E>> Expect<T>.toContainElementsOf(expectedIterableLike: IterableLike): Expect<T>

Expects that the subject of this expectation (an Iterable) contains all elements of expectedIterableLike.

toContainEntriesOf

infix fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContainEntriesOf(mapLike: MapLike): Expect<T>

Expects that the subject of this expectation (a Map) contains the key-value pairs of the given mapLike.

toContainExactly

infix fun <E, T : Iterable<E>> Expect<T>.toContainExactly(expected: E): Expect<T>

Expects that the subject of this expectation (an Iterable) contains only the expected value.

infix fun <E, T : Iterable<E>> Expect<T>.toContainExactly(values: Values<E>): Expect<T>

@JvmName(name = "toContainExactlyValuesWithReportingOption")

infix fun <E, T : Iterable<E>> Expect<T>.toContainExactly(values: WithInOrderOnlyReportingOptions<Values<E>>): Expect<T>

Expects that the subject of this expectation (an Iterable) contains only the expected values in the defined order.

@JvmName(name = "toContainExactlyElementsOfWithReportingOption")

infix inline fun <E, T : Iterable<E>> Expect<T>.toContainExactly(elementsOf: WithInOrderOnlyReportingOptions<IterableLike>): Expect<T>

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

infix fun <E : Any, T : Iterable<E?>> Expect<T>.toContainExactly(entries: Entries<E>): Expect<T>

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

@JvmName(name = "toContainExactlyEntriesWithReportingOption")

infix fun <E : Any, T : Iterable<E?>> Expect<T>.toContainExactly(entries: WithInOrderOnlyReportingOptions<Entries<E>>): Expect<T>

infix fun <E : Any, T : Iterable<E?>> Expect<T>.toContainExactly(assertionCreatorOrNull: Expect<E>.() -> Unit?): Expect<T>

Expects that the subject of this expectation (an Iterable) contains only an entry holding the assertions created by assertionCreatorOrNull or only one entry which is null in case assertionCreatorOrNull is defined as null.

toContainExactlyElementsOf

infix inline fun <E, T : Iterable<E>> Expect<T>.toContainExactlyElementsOf(expectedIterableLike: IterableLike): Expect<T>

Expects that the subject of this expectation (an Iterable) contains only elements of expectedIterableLike in same order

toContainKey

infix fun <K, T : Map<out K, *>> Expect<T>.toContainKey(key: K): Expect<T>

Expects that the subject of this expectation (a Map) contains the given key.

toContainOnly

infix fun <K, V, T : Map<out K, V>> Expect<T>.toContainOnly(pairs: Pairs<K, V>): Expect<T>

Expects the subject of this expectation (a Map) contains only (in any order) for each key-value pair in pairs, a key as defined by that entry's Pair.first with a corresponding value as defined by entry's Pair.second.

infix fun <K, V, T : Map<out K, V>> Expect<T>.toContainOnly(keyValuePair: Pair<K, V>): Expect<T>

Expects that the subject of this expectation (a Map) contains only one entry with a key as defined by keyValuePair's Pair.first and a corresponding value as defined by keyValuePair's Pair.second

infix inline fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContainOnly(keyValues: KeyValues<K, V>): Expect<T>

Expects that the subject of this expectation (a Map) contains only (in any order) for each KeyWithValueCreator in keyValues, a key as defined by KeyWithValueCreator.key with a corresponding value which either holds all assertions KeyWithValueCreator's KeyWithValueCreator.valueAssertionCreatorOrNull creates or needs to be null in case KeyWithValueCreator.valueAssertionCreatorOrNull is defined as null

infix inline fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContainOnly(keyValue: KeyWithValueCreator<K, V>): Expect<T>

Expects that the subject of this expectation (a Map) contains only one entry with a key as defined by keyValue's KeyWithValueCreator.key with a corresponding value which either holds all assertions keyValue's KeyWithValueCreator.valueAssertionCreatorOrNull creates or needs to be null in case KeyWithValueCreator.valueAssertionCreatorOrNull is defined as null

toContainOnlyEntriesOf

infix fun <K, V : Any, T : Map<out K, V?>> Expect<T>.toContainOnlyEntriesOf(mapLike: MapLike): Expect<T>

Expects that the subject of this expectation (a Map) contains only (in any order) the key-value pairs of the given mapLike.

toContainRegex

infix fun <T : CharSequence> Expect<T>.toContainRegex(pattern: String): Expect<T>

Expects that the subject of this expectation (a CharSequence) contains a sequence which matches the given regular expression pattern.

toEndWith

infix fun <T : CharSequence> Expect<T>.toEndWith(expected: CharSequence): Expect<T>

Expects that the subject of this expectation (a CharSequence) ends with expected.

infix fun <T : Path> Expect<T>.toEndWith(expected: Path): Expect<T>

Expects that the subject of this expectation (a Path) ends with the expected Path.

toEqual

infix fun <T> Expect<T>.toEqual(expected: T): Expect<T>

Expects that the subject of this expectation is (equal to) expected where the comparison is carried out based on Any.equals.

@JvmName(name = "toBeNullable")

infix fun <T : BigDecimal?> Expect<T>.~~toEqual~~(expected: T): Nothing

infix fun <T : BigDecimal> Expect<T>.~~toEqual~~(expected: T): Nothing

Deprecated as it would compare the subject against expected including scale -- many developers are not aware of that.

@JvmName(name = "toBeNull")

infix fun <T : BigDecimal> Expect<T?>.toEqual(expected: Nothing?): Expect<T?>

Expects that the subject of this expectation (a BigDecimal) is null.

toEqualIncludingScale

infix fun <T : BigDecimal> Expect<T>.toEqualIncludingScale(expected: T): Expect<T>

Expects that the subject of this expectation (a BigDecimal) is equal to expected including BigDecimal.scale.

toEqualKeyValue

infix fun <K, V, T : Map.Entry<K, V>> Expect<T>.toEqualKeyValue(keyValuePair: Pair<K, V>): Expect<T>

Expects that the property Map.Entry.key of the subject of this expectation is equal to the given key and the property Map.Entry.value is equal to the given value.

toEqualNullIfNullGivenElse

infix fun <T : Any> Expect<T?>.toEqualNullIfNullGivenElse(assertionCreatorOrNull: Expect<T>.() -> Unit?): Expect<T?>

Expects that the subject of this expectation is either null in case assertionCreatorOrNull is null or is not null and holds all assertions assertionCreatorOrNull creates.

toEqualNumerically

infix fun <T : BigDecimal> Expect<T>.toEqualNumerically(expected: T): Expect<T>

Expects that the subject of this expectation (a BigDecimal) is numerically equal to expected.

toHave

infix fun <E, T : Iterable<E>> Expect<T>.toHave(elements: elements): Expect<T>

Expects that the subject of this expectation (an Iterable) has at least one element.

infix fun <T : Iterator<*>> Expect<T>.toHave(next: next): Expect<T>

Expects that the subject of this expectation (an Iterator) has a next element.

infix fun <T : Path> Expect<T>.toHave(directoryEntries: DirectoryEntries): Expect<T>

Expects that the subject of this expectation (a Path) is a directory having the provided entries. That means that there is a file system entry at the location the Path points to and that it is a directory. Furthermore, every argument string resolved against the subject yields an existing file system entry.

toHaveElementsAnd

infix fun <E, T : Iterable<E>> Expect<T>.toHaveElementsAnd(noDuplicates: noDuplicates): Expect<T>

Expects that the subject of this expectation (an Iterable) does not have duplicate elements.

toHaveElementsAndAll

infix fun <E : Any, T : Iterable<E?>> Expect<T>.toHaveElementsAndAll(assertionCreatorOrNull: Expect<E>.() -> Unit?): Expect<T>

Expects that the subject of this expectation (an Iterable) has at least one element and that either every element holds all assertions created by the assertionCreatorOrNull or that all elements are null in case assertionCreatorOrNull is defined as null.

toHaveElementsAndAny

infix fun <E : Any, T : Iterable<E?>> Expect<T>.toHaveElementsAndAny(assertionCreatorOrNull: Expect<E>.() -> Unit?): Expect<T>

toHaveElementsAndNone

infix fun <E : Any, T : Iterable<E?>> Expect<T>.toHaveElementsAndNone(assertionCreatorOrNull: Expect<E>.() -> Unit?): Expect<T>

Expects that the subject of this expectation (an Iterable) has at least one element and that it either does not contain a single entry which holds all assertions created by assertionCreatorOrNull or that it does not contain a single entry which is null in case assertionCreatorOrNull is defined as null.

toHaveSize

infix fun <T : Collection<*>> Expect<T>.toHaveSize(expected: Int): Expect<T>

Expects that the subject of this expectation (a Collection) has the given expected size.

toHaveTheSameBinaryContentAs

infix fun <T : Path> Expect<T>.toHaveTheSameBinaryContentAs(targetPath: Path): Expect<T>

Expects that the subject of this expectation (a Path) has the same binary content as targetPath.

toHaveTheSameTextualContentAs

infix fun <T : Path> Expect<T>.toHaveTheSameTextualContentAs(pathWithEncoding: PathWithEncoding): Expect<T>

Expects that the subject of this expectation (a Path) has the same textual content as PathWithEncoding.path in the given pathWithEncoding with the specified encodings.

infix fun <T : Path> Expect<T>.toHaveTheSameTextualContentAs(targetPath: Path): Expect<T>

Expects that the subject of this expectation (a Path) has the same textual content as targetPath (using UTF-8 for encoding)

toMatch

infix fun <T : CharSequence> Expect<T>.toMatch(pattern: Regex): Expect<T>

Expects that the subject of this expectation (a CharSequence) matches the given Regex.

toStartWith

infix fun <T : CharSequence> Expect<T>.toStartWith(expected: CharSequence): Expect<T>

Expects that the subject of this expectation (a CharSequence) starts with expected.

infix fun <T : Path> Expect<T>.toStartWith(expected: Path): Expect<T>

Expects that the subject of this expectation (a Path) starts with the expected.

toThrow

inline fun <TExpected : Throwable> Expect<out () -> Any?>.toThrow(): Expect<TExpected>

Expects that invoking the subject (a function with arity 0, i.e. without arguments) throws a TExpected (the same type or a sub-type).

infix inline fun <TExpected : Throwable> Expect<out () -> Any?>.toThrow(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>

Expects that invoking the subject (a function with arity 0, i.e. without arguments) throws a TExpected (the same type or a sub-type) and that it holds all assertions the given assertionCreator creates.

types

fun types(type: KClass<*>, vararg otherTypes: KClass<*>): Types

Helper function to create a Types based on the given type and otherTypes -- allows expressing KClass<*>, vararg KClass<*>.

value

fun <T> value(value: T): Value<T>

Helper function to create a Value based on the given value.

value

infix fun <K, V, T : Map.Entry<K, V>> Expect<T>.value(assertionCreator: Expect<V>.() -> Unit): Expect<T>

Expects that the property Map.Entry.value of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

@JvmName(name = "valueIgnoringCase")

infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the expected value shall be searched (ignoring case), using a non-disjoint search.

infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the expected object shall be searched, using a non-disjoint search.

infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>

Finishes the specification of the sophisticated to contain expectation where the expected value shall be searched (ignoring case), using a non-disjoint search where it needs to be contained at least once.

infix fun <E, T : IterableLike> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.value(expected: E): Expect<T>

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

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

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

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

values

fun <T> values(value: T, vararg otherValues: T): Values<T>

Helper function to create a Values based on the given value and otherValues -- allows expressing T, vararg T.

fun <T> values(value: T, vararg otherValues: T, reportOptionsInAnyOrderOnly: InAnyOrderOnlyReportingOptions.() -> Unit): WithInAnyOrderOnlyReportingOptions<Values<T>>

Helper function to create a WithInOrderOnlyReportingOptions wrapping a Values based on the given value and otherValues as well as the given reportOptionsInAnyOrderOnly-configuration-lambda -- allows expressing T, vararg T, reportOptionsInAnyOrderOnly = { ... }.

fun <T> values(value: T, vararg otherValues: T, reportOptionsInOrderOnly: InOrderOnlyReportingOptions.() -> Unit): WithInOrderOnlyReportingOptions<Values<T>>

Helper function to create a WithInOrderOnlyReportingOptions wrapping a Values based on the given value and otherValues as well as the given reportOptionsInOrderOnly-configuration-lambda -- allows expressing T, vararg T, reportOptionsInOrderOnly = { ... }.

values

infix fun <K, V, T : Map<out K, V>> Expect<T>.values(assertionCreator: Expect<Collection<V>>.() -> Unit): Expect<T>

withEncoding

fun withEncoding(path: Path, sourceCharset: Charset = Charsets.UTF_8, targetCharset: Charset = Charsets.UTF_8): PathWithEncoding

Helper function to create a PathWithEncoding based on the given path and the sourceCharset and targetCharset where UTF-8 is used as default if one encoding is missing.

within

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

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

withOptions

infix fun <T, R> FeatureExpect<T, R>.withOptions(options: FeatureExpectOptions<R>): Expect<R>

infix fun <T> RootExpect<T>.withOptions(options: RootExpectOptions<T>): Expect<T>

Uses the given options to override (parts) of the existing configuration.

infix fun <T, R> FeatureExpect<T, R>.withOptions(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): Expect<R>

Uses the given configuration-lambda to create an FeatureExpectOptions which in turn is used to re-define (parts) of the existing configuration.

infix fun <T> RootExpect<T>.withOptions(configuration: RootExpectBuilder.OptionsChooser<T>.() -> Unit): Expect<T>

Uses the given configuration-lambda to create an RootExpectOptions which in turn is used to override (parts) of the existing configuration.

withRepresentation

infix fun <T, R> FeatureExpect<T, R>.withRepresentation(representationProvider: (R) -> Any): Expect<R>

infix fun <T> RootExpect<T>.withRepresentation(representationProvider: (T) -> Any): Expect<T>

Uses the given representationProvider to retrieve a representation which can be based on the current subject where it is used as new representation of the subject instead of the representation that has been defined so far (which defaults to the subject itself).

infix fun <T, R> FeatureExpect<T, R>.withRepresentation(textRepresentation: String): Expect<R>

infix fun <T> RootExpect<T>.withRepresentation(textRepresentation: String): Expect<T>

Wraps the given textRepresentation into a Text and uses it as representation of the subject instead of the representation that has been defined so far (which defaults to the subject itself).

year

infix fun Expect<LocalDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>

Expects that the property LocalDateTime.year of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

infix fun Expect<LocalDate>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>

Expects that the property LocalDate.yearof the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.

infix fun Expect<ZonedDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>

Expects that the property ZonedDateTime.year of the subject of this expectation holds all assertions the given assertionCreator creates for it and returns an Expect for the current subject of this expectation.