Assert

sealed class Assert<out T>

Platform and version requirements: Common

An assertion. Holds an actual value to assertion on and an optional name.

See Also

Properties

actual	`val actual: T`
name	`val name: String?`

Functions

assert	`fun <R> assert(actual: R, name: String? = this.name): Assert<R>` Asserts on the given value with an optional name.
assertThat	`abstract fun <R> assertThat(actual: R, name: String? = this.name): Assert<R>` Asserts on the given value with an optional name.
given	`fun given(assertion: (T) -> Unit): Unit` Allows checking the actual value of an assert. This can be used to build your own custom assertions.
transform	`fun <R> transform(name: String? = this.name, transform: (T) -> R): Assert<R>` Transforms an assertion from one type to another. If the assertion is failing the resulting assertion will still be failing, otherwise the mapping function is called. An optional name can be provided, otherwise this assertion's name will be used.

Extension Functions

all (Common)	`fun <T> Assert<T>.all(message: String = SoftFailure.defaultMessage, body: Assert<T>.() -> Unit): Unit` All assertions in the given lambda are run.
atLeast (Common)	`fun <E, T : Iterable<E>> Assert<T>.atLeast(times: Int, f: (Assert<E>) -> Unit): Unit` Asserts on each item in the iterable, passing if at least `times` items pass. The given lambda will be run for each item.
atMost (Common)	`fun <E, T : Iterable<E>> Assert<T>.atMost(times: Int, f: (Assert<E>) -> Unit): Unit` Asserts on each item in the iterable, passing if at most `times` items pass. The given lambda will be run for each item.
cause (Common)	`fun Assert<Throwable>.cause(): Assert<Throwable?>` Returns an assert on the throwable's cause.
contains (Common)	`fun <T> Assert<Array<T>>.contains(element: Any?): Unit` Asserts the array contains the expected element, using `in`. `fun Assert<Iterable<*>>.contains(element: Any?): Unit` Asserts the iterable contains the expected element, using `in`. `fun <K, V> Assert<Map<K, V>>.contains(key: K, value: V): Unit` `fun <K, V> Assert<Map<K, V>>.contains(element: <ERROR CLASS><K, V>): Unit` Asserts the map contains the expected key-value pair. `fun Assert<String>.contains(other: CharSequence, ignoreCase: Boolean = false): Unit` Asserts the string contains the expected string.
containsAll (Common)	`fun <T> Assert<Array<T>>.containsAll(vararg elements: Any?): Unit` Asserts the array contains all the expected elements, in any order. The array may also contain additional elements. `fun Assert<Collection<*>>.containsAll(vararg elements: Any?): Unit` Asserts the collection contains all the expected elements, in any order. The collection may also contain additional elements. `fun <K, V> Assert<Map<K, V>>.containsAll(vararg elements: <ERROR CLASS><K, V>): Unit` Asserts the map contains all the expected elements. The map may also contain additional elements.
containsExactly (Common)	`fun <T> Assert<Array<T>>.containsExactly(vararg elements: Any?): Unit` Asserts the array contains exactly the expected elements. They must be in the same order and there must not be any extra elements. `fun Assert<List<*>>.containsExactly(vararg elements: Any?): Unit` Asserts the list contains exactly the expected elements. They must be in the same order and there must not be any extra elements.
containsNone (Common)	`fun <T> Assert<Array<T>>.containsNone(vararg elements: Any?): Unit` `fun Assert<Collection<*>>.containsNone(vararg elements: Any?): Unit` Asserts the collection does not contain any of the expected elements. `fun <K, V> Assert<Map<K, V>>.containsNone(vararg elements: <ERROR CLASS><K, V>): Unit` Asserts the map does not contain any of the expected elements.
containsOnly (Common)	`fun Assert<Collection<*>>.containsOnly(vararg elements: Any?): Unit` Asserts the collection contains only the expected elements `fun <K, V> Assert<Map<K, V>>.containsOnly(vararg elements: <ERROR CLASS><K, V>): Unit` Asserts the map contains only the expected elements. There must not be any extra elements.
doesNotContain (Common)	`fun <T> Assert<Array<T>>.doesNotContain(element: Any?): Unit` Asserts the array does not contain the expected element, using `!in`. `fun Assert<Iterable<*>>.doesNotContain(element: Any?): Unit` Asserts the iterable does not contain the expected element, using `!in`. `fun <K, V> Assert<Map<K, V>>.doesNotContain(key: K, value: V): Unit` `fun <K, V> Assert<Map<K, V>>.doesNotContain(element: <ERROR CLASS><K, V>): Unit` Asserts the map does not contain the expected key-value pair. `fun Assert<String>.doesNotContain(other: CharSequence, ignoreCase: Boolean = false): Unit` Asserts the string does not contain the specified string.
doesNotHaveClass (Common)	`fun <T : Any> Assert<T>.doesNotHaveClass(kclass: KClass<out T>): Unit` Asserts the value does not have the expected kotlin class. This is an exact match, so `assertThat("test").doesNotHaveClass(String::class)` is fails but `assertThat("test").doesNotHaveClass(Any::class)` is successful.
each (Common)	`fun <T> Assert<Array<T>>.each(f: (Assert<T>) -> Unit): Unit` Asserts on each item in the array. The given lambda will be run for each item. `fun <E> Assert<Iterable<E>>.each(f: (Assert<E>) -> Unit): Unit` Asserts on each item in the iterable. The given lambda will be run for each item.
endsWith (Common)	`fun Assert<String>.endsWith(other: String, ignoreCase: Boolean = false): Unit` Asserts the string ends with the expected string.
exactly (Common)	`fun <E, T : Iterable<E>> Assert<T>.exactly(times: Int, f: (Assert<E>) -> Unit): Unit` Asserts on each item in the iterable, passing if exactly `times` items pass. The given lambda will be run for each item.
expected (Common)	`fun <T> Assert<T>.expected(message: String, expected: Any? = NONE, actual: Any? = NONE): Nothing` Fails an assert with the given expected message. These should be in the format:
fail (Common)	`fun <T> Assert<T>.fail(expected: Any?, actual: Any?): Unit` Fails an assert with the given expected and actual values.
hasCause (Common)	`fun Assert<Throwable>.hasCause(cause: Throwable): Unit` Asserts the throwable is similar to the expected cause, checking the type and message.
hasClass (Common)	`fun <T : Any> Assert<T>.hasClass(kclass: KClass<out T>): Unit` Asserts the value has the expected kotlin class. This is an exact match, so `assertThat("test").hasClass(String::class)` is successful but `assertThat("test").hasClass(Any::class)` fails.
hasHashCode (Common)	`fun Assert<Any>.hasHashCode(hashCode: Int): Unit` Asserts the value has the expected hash code from it's hashCode.
hasLength (Common)	`fun Assert<CharSequence>.hasLength(length: Int): Unit` Asserts the char sequence has the expected length.
hasLineCount (Common)	`fun Assert<String>.hasLineCount(lineCount: Int): Unit` Asserts the string has the expected number of lines.
hasMessage (Common)	`fun Assert<Throwable>.hasMessage(message: String?): Unit` Asserts the throwable has the expected message.
hasNoCause (Common)	`fun Assert<Throwable>.hasNoCause(): Unit` Asserts the throwable has no cause.
hasRootCause (Common)	`fun Assert<Throwable>.hasRootCause(cause: Throwable): Unit` Asserts the throwable is similar to the expected root cause, checking the type and message.
hasSameLengthAs (Common)	`fun Assert<CharSequence>.hasSameLengthAs(other: CharSequence): Unit` Asserts the char sequence has the same length as the expected one.
hasSameSizeAs (Common)	`fun <T> Assert<Array<T>>.hasSameSizeAs(other: Array<>): Unit` Asserts the array has the same size as the expected array. `fun Assert<Collection<>>.hasSameSizeAs(other: Collection<>): Unit` Asserts the collection has the same size as the expected collection. `fun Assert<Map<, >>.hasSameSizeAs(other: Map<, *>): Unit` Asserts the map has the same size as the expected map.
hasSize (Common)	`fun Assert<Array<>>.hasSize(size: Int): Unit` Asserts the array has the expected size. `fun Assert<Collection<>>.hasSize(size: Int): Unit` `fun Assert<Map<, >>.hasSize(size: Int): Unit` Asserts the collection has the expected size.
hasToString (Common)	`fun <T> Assert<T>.hasToString(string: String): Unit` Asserts the value has the expected string from it's toString.
hashCodeFun (Common)	`fun <T : Any> Assert<T>.hashCodeFun(): Assert<Int>` Returns an assert on the hasCode method of the value.
index (Common)	`fun <T> Assert<Array<T>>.index(index: Int, f: (Assert<T>) -> Unit): Unit` `fun <T> Assert<Array<T>>.index(index: Int): Assert<T>` Returns an assert that assertion on the value at the given index in the array. `fun <T> Assert<List<T>>.index(index: Int, f: (Assert<T>) -> Unit): Unit` `fun <T> Assert<List<T>>.index(index: Int): Assert<T>` Returns an assert that assertion on the value at the given index in the list.
isBetween (Common)	`fun <A, B : Comparable<A>> Assert<B>.isBetween(start: A, end: A): Unit` Asserts the value is between the expected start and end values, inclusive.
isCloseTo (Common)	`fun Assert<Float>.isCloseTo(value: Float, delta: Float): Unit` `fun Assert<Double>.isCloseTo(value: Double, delta: Double): Unit` Asserts the value if it is close to the expected value with given delta.
isEmpty (Common)	`fun Assert<Array<>>.isEmpty(): Unit` Asserts the array is empty. `fun Assert<CharSequence>.isEmpty(): Unit` Asserts the char sequence is empty. `fun Assert<Collection<>>.isEmpty(): Unit` `fun Assert<Map<, >>.isEmpty(): Unit` Asserts the collection is empty. `fun Assert<Iterable<*>>.isEmpty(): Unit` Asserts the iterable is empty.
isEqualTo (Common)	`fun <T> Assert<T>.isEqualTo(expected: Any?): Unit` Asserts the value is equal to the expected one, using `==`. `fun <T> Assert<Array<T>>.isEqualTo(expected: Array<T>): Unit` Asserts the array contents are equal to the expected one, using contentDeepEquals. `fun Assert<String?>.isEqualTo(other: String?, ignoreCase: Boolean = false): Unit` Asserts the string is equal to the expected string.
isEqualToWithGivenProperties (Common)	`fun <T> Assert<T>.isEqualToWithGivenProperties(other: T, vararg properties: KProperty1<T, Any>): Unit` Returns an assert that compares only the given properties on the calling class
isFalse (Common)	`fun Assert<Boolean>.isFalse(): Unit` Asserts the boolean is false.
isGreaterThan (Common)	`fun <A, B : Comparable<A>> Assert<B>.isGreaterThan(other: A): Unit` Asserts the value is greater than the expected value, using `>`.
isGreaterThanOrEqualTo (Common)	`fun <A, B : Comparable<A>> Assert<B>.isGreaterThanOrEqualTo(other: A): Unit` Asserts the value is greater or equal to the expected value, using `>=`.
isIn (Common)	`fun <T> Assert<T>.isIn(vararg values: T): Unit` Asserts the value is in the expected values, using `in`.
isInstanceOf (Common)	`fun <T : Any, S : T> Assert<T>.isInstanceOf(kclass: KClass<S>, f: (Assert<S>) -> Unit): Unit` `fun <T : Any, S : T> Assert<T>.isInstanceOf(kclass: KClass<S>): Assert<S>` Asserts the value is an instance of the expected kotlin class. Both `assertThat("test").isInstanceOf(String::class)` and `assertThat("test").isInstanceOf(Any::class)` is successful.
isLessThan (Common)	`fun <A, B : Comparable<A>> Assert<B>.isLessThan(other: A): Unit` Asserts the value is less than the expected value, using `<`.
isLessThanOrEqualTo (Common)	`fun <A, B : Comparable<A>> Assert<B>.isLessThanOrEqualTo(other: A): Unit` Asserts the value is less than or equal to the expected value, using `<=`.
isNegative (Common)	`fun <T : Number> Assert<T>.isNegative(): Unit` Asserts the number is less than 0.
isNotEmpty (Common)	`fun Assert<Array<>>.isNotEmpty(): Unit` Asserts the array is not empty. `fun Assert<CharSequence>.isNotEmpty(): Unit` Asserts the char sequence is not empty. `fun Assert<Collection<>>.isNotEmpty(): Unit` `fun Assert<Map<, >>.isNotEmpty(): Unit` Asserts the collection is not empty. `fun Assert<Iterable<*>>.isNotEmpty(): Unit` Asserts the iterable is not empty.
isNotEqualTo (Common)	`fun <T> Assert<T>.isNotEqualTo(expected: Any?): Unit` Asserts the value is not equal to the expected one, using `!=`. `fun <T> Assert<Array<T>>.isNotEqualTo(expected: Array<T>): Unit` Asserts the array contents are not equal to the expected one, using contentDeepEquals. `fun Assert<String?>.isNotEqualTo(other: String?, ignoreCase: Boolean = false): Unit` Asserts the string is not equal to the expected string.
isNotIn (Common)	`fun <T> Assert<T>.isNotIn(vararg values: T): Unit` Asserts the value is not in the expected values, using `!in`.
isNotInstanceOf (Common)	`fun <T : Any> Assert<T>.isNotInstanceOf(kclass: KClass<out T>): Unit` Asserts the value is not an instance of the expected kotlin class. Both `assertThat("test").isNotInstanceOf(String::class)` and `assertThat("test").isNotInstanceOf(Any::class)` fails.
isNotNull (Common)	`fun <T : Any> Assert<T?>.isNotNull(f: (Assert<T>) -> Unit): Unit` `fun <T : Any> Assert<T?>.isNotNull(): Assert<T>` Asserts the value is not null. You can pass in an optional lambda to run additional assertions on the non-null value.
isNotSameAs (Common)	`fun <T> Assert<T>.isNotSameAs(expected: Any?): Unit` Asserts the value is not the same as the expected one, using `!==`.
isNotZero (Common)	`fun <T : Number> Assert<T>.isNotZero(): Unit` Asserts the number is not 0.
isNull (Common)	`fun <T : Any> Assert<T?>.isNull(): Unit` Asserts the value is null.
isNullOrEmpty (Common)	`fun Assert<Array<>?>.isNullOrEmpty(): Unit` Asserts the array is null or empty. `fun Assert<CharSequence?>.isNullOrEmpty(): Unit` Asserts the char sequence is null or empty. `fun Assert<Collection<>?>.isNullOrEmpty(): Unit` `fun Assert<Map<, >?>.isNullOrEmpty(): Unit` Asserts the collection is null or empty.
isPositive (Common)	`fun <T : Number> Assert<T>.isPositive(): Unit` Asserts the number is greater than 0.
isSameAs (Common)	`fun <T> Assert<T>.isSameAs(expected: T): Unit` Asserts the value is the same as the expected one, using `===`.
isStrictlyBetween (Common)	`fun <A, B : Comparable<A>> Assert<B>.isStrictlyBetween(start: A, end: A): Unit` Asserts the value is between the expected start and end values, non-inclusive.
isTrue (Common)	`fun Assert<Boolean>.isTrue(): Unit` Asserts the boolean is true.
isZero (Common)	`fun <T : Number> Assert<T>.isZero(): Unit` Asserts the number is 0.
kClass (Common)	`fun <T : Any> Assert<T>.kClass(): Assert<KClass<out T>>` Returns an assert on the kotlin class of the value.
key (Common)	`fun <K, V> Assert<Map<K, V>>.key(key: K, f: (Assert<V>) -> Unit): Unit` `fun <K, V> Assert<Map<K, V>>.key(key: K): Assert<V>` Returns an assert that asserts on the value at the given key in the map.
length (Common)	`fun Assert<CharSequence>.length(): Assert<Int>` Returns an assert on the CharSequence's length.
matches (Common)	`fun Assert<String>.matches(regex: <ERROR CLASS>): Unit` Asserts the string matches the expected regular expression.
matchesPredicate (Common)	`fun <T> Assert<T>.matchesPredicate(f: (T) -> Boolean): Unit` Asserts if the values satisfies the predicate provided.
message (Common)	`fun Assert<Throwable>.message(): Assert<String?>` Returns an assert on the throwable's message.
none (Common)	`fun <E> Assert<Iterable<E>>.none(f: (Assert<E>) -> Unit): Unit` Asserts on each item in the iterable, passing if none of the items pass. The given lambda will be run for each item.
prop (Common)	`fun <T, P> Assert<T>.prop(name: String, extract: (T) -> P): Assert<P>` Returns an assert that asserts on the given property of the value.
rootCause (Common)	`fun Assert<Throwable>.rootCause(): Assert<Throwable>` Returns an assert on the throwable's root cause.
size (Common)	`fun Assert<Array<>>.size(): Assert<Int>` Returns an assert on the Arrays's size. `fun Assert<Collection<>>.size(): Assert<Int>` Returns an assert on the Collection's size. `fun Assert<Map<, >>.size(): Assert<Int>` Returns an assert on the Maps's size.
startsWith (Common)	`fun Assert<String>.startsWith(other: String, ignoreCase: Boolean = false): Unit` Asserts the string starts with the expected string.
toStringFun (Common)	`fun <T> Assert<T>.toStringFun(): Assert<String>` Returns an assert on the toString method of the value.

Inheritors

FailingAssert (Common)	`class FailingAssert<out T> : Assert<T>`
ValueAssert (Common)	`class ValueAssert<out T> : Assert<T>`