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, body: Assert<T>.() -> Unit): Unit` `fun <T> Assert<T>.all(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.
bytes	`fun Assert<File>.bytes(): Assert<ByteArray>` Returns an assert on the file's contents as bytes. `fun Assert<Path>.bytes(): Assert<ByteArray>` Assert on file bytes
cause (Common)	`fun Assert<Throwable>.cause(): Assert<Throwable?>` Returns an assert on the throwable's cause.
contains	`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: Pair<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. `fun Assert<ByteArray>.contains(element: Byte): Unit` Asserts the ByteArray contains the expected element, using `in`. `fun Assert<IntArray>.contains(element: Int): Unit` Asserts the IntArray contains the expected element, using `in`. `fun Assert<ShortArray>.contains(element: Short): Unit` Asserts the ShortArray contains the expected element, using `in`. `fun Assert<LongArray>.contains(element: Long): Unit` Asserts the LongArray contains the expected element, using `in`. `fun Assert<FloatArray>.contains(element: Float): Unit` Asserts the FloatArray contains the expected element, using `in`. `fun Assert<DoubleArray>.contains(element: Double): Unit` Asserts the DoubleArray contains the expected element, using `in`. `fun Assert<CharArray>.contains(element: Char): Unit` Asserts the CharArray contains the expected element, using `in`.
containsAll	`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: Pair<K, V>): Unit` Asserts the map contains all the expected elements. The map may also contain additional elements. `fun Assert<ByteArray>.containsAll(vararg elements: Byte): Unit` Asserts the ByteArray contains all the expected elements, in any order. The array may also contain additional elements. `fun Assert<IntArray>.containsAll(vararg elements: Int): Unit` Asserts the IntArray contains all the expected elements, in any order. The array may also contain additional elements. `fun Assert<ShortArray>.containsAll(vararg elements: Short): Unit` Asserts the ShortArray contains all the expected elements, in any order. The array may also contain additional elements. `fun Assert<LongArray>.containsAll(vararg elements: Long): Unit` Asserts the LongArray contains all the expected elements, in any order. The array may also contain additional elements. `fun Assert<FloatArray>.containsAll(vararg elements: Float): Unit` Asserts the FloatArray contains all the expected elements, in any order. The array may also contain additional elements. `fun Assert<DoubleArray>.containsAll(vararg elements: Double): Unit` Asserts the DoubleArray contains all the expected elements, in any order. The array may also contain additional elements. `fun Assert<CharArray>.containsAll(vararg elements: Char): Unit` Asserts the CharArray contains all the expected elements, in any order. The array may also contain additional elements.
containsExactly	`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. `fun Assert<ByteArray>.containsExactly(vararg elements: Byte): Unit` Asserts the ByteArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements. `fun Assert<IntArray>.containsExactly(vararg elements: Int): Unit` Asserts the IntArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements. `fun Assert<ShortArray>.containsExactly(vararg elements: Short): Unit` Asserts the ShortArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements. `fun Assert<LongArray>.containsExactly(vararg elements: Long): Unit` Asserts the LongArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements. `fun Assert<FloatArray>.containsExactly(vararg elements: Float): Unit` Asserts the FloatArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements. `fun Assert<DoubleArray>.containsExactly(vararg elements: Double): Unit` Asserts the DoubleArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements. `fun Assert<CharArray>.containsExactly(vararg elements: Char): Unit` Asserts the CharArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.
containsNone	`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: Pair<K, V>): Unit` Asserts the map does not contain any of the expected elements. `fun Assert<ByteArray>.containsNone(vararg elements: Byte): Unit` Asserts the ByteArray does not contain any of the expected elements. `fun Assert<IntArray>.containsNone(vararg elements: Int): Unit` Asserts the IntArray does not contain any of the expected elements. `fun Assert<ShortArray>.containsNone(vararg elements: Short): Unit` Asserts the ShortArray does not contain any of the expected elements. `fun Assert<LongArray>.containsNone(vararg elements: Long): Unit` Asserts the LongArray does not contain any of the expected elements. `fun Assert<FloatArray>.containsNone(vararg elements: Float): Unit` Asserts the FloatArray does not contain any of the expected elements. `fun Assert<DoubleArray>.containsNone(vararg elements: Double): Unit` Asserts the DoubleArray does not contain any of the expected elements. `fun Assert<CharArray>.containsNone(vararg elements: Char): Unit` Asserts the CharArray 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: Pair<K, V>): Unit` Asserts the map contains only the expected elements. There must not be any extra elements.
doesNotContain	`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: Pair<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. `fun Assert<ByteArray>.doesNotContain(element: Byte): Unit` Asserts the ByteArray does not contain the expected element, using `!in`. `fun Assert<IntArray>.doesNotContain(element: Int): Unit` Asserts the IntArray does not contain the expected element, using `!in`. `fun Assert<ShortArray>.doesNotContain(element: Short): Unit` Asserts the ShortArray does not contain the expected element, using `!in`. `fun Assert<LongArray>.doesNotContain(element: Long): Unit` Asserts the LongArray does not contain the expected element, using `!in`. `fun Assert<FloatArray>.doesNotContain(element: Float): Unit` Asserts the FloatArray does not contain the expected element, using `!in`. `fun Assert<DoubleArray>.doesNotContain(element: Double): Unit` Asserts the DoubleArray does not contain the expected element, using `!in`. `fun Assert<CharArray>.doesNotContain(element: Char): Unit` Asserts the CharArray does not contain the expected element, using `!in`.
doesNotHaveClass	`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. `fun <T : Any> Assert<T>.doesNotHaveClass(jclass: Class<out T>): Unit` Asserts the value does not have the expected java class. This is an exact match, so `assertThat("test").doesNotHaveClass(String::class.java)` is fails but `assertThat("test").doesNotHaveClass(Any::class.java)` is successful.
doesNotThrowAnyException (Common)	`fun <T> Assert<Result<T>>.doesNotThrowAnyException(): Unit`
each	`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. `fun Assert<ByteArray>.each(f: (Assert<Byte>) -> Unit): Unit` Asserts on each item in the ByteArray. The given lambda will be run for each item. `fun Assert<IntArray>.each(f: (Assert<Int>) -> Unit): Unit` Asserts on each item in the IntArray. The given lambda will be run for each item. `fun Assert<ShortArray>.each(f: (Assert<Short>) -> Unit): Unit` Asserts on each item in the ShortArray. The given lambda will be run for each item. `fun Assert<LongArray>.each(f: (Assert<Long>) -> Unit): Unit` Asserts on each item in the LongArray. The given lambda will be run for each item. `fun Assert<FloatArray>.each(f: (Assert<Float>) -> Unit): Unit` Asserts on each item in the FloatArray. The given lambda will be run for each item. `fun Assert<DoubleArray>.each(f: (Assert<Double>) -> Unit): Unit` Asserts on each item in the DoubleArray. The given lambda will be run for each item. `fun Assert<CharArray>.each(f: (Assert<Char>) -> Unit): Unit` Asserts on each item in the CharArray. 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.
exists	`fun Assert<File>.exists(): Unit` Asserts the file exists.
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:
extension	`fun Assert<File>.extension(): Assert<String>` Returns an assert on the file's extension.
extracting (Common)	`fun <E, R> Assert<Array<E>>.extracting(f1: (E) -> R): Assert<List<R>>` Extracts a value of from each item in the array, allowing you to assert on a list of those values. `fun <E, R1, R2> Assert<Array<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): Assert<List<Pair<R1, R2>>>` Extracts two values of from each item in the array, allowing you to assert on a list of paris of those values. `fun <E, R1, R2, R3> Assert<Array<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2, f3: (E) -> R3): Assert<List<Triple<R1, R2, R3>>>` Extracts three values from each item in the array, allowing you to assert on a list of triples of those values. `fun <E, R> Assert<Iterable<E>>.extracting(f1: (E) -> R): Assert<List<R>>` Extracts a value of from each item in the iterable, allowing you to assert on a list of those values. `fun <E, R1, R2> Assert<Iterable<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): Assert<List<Pair<R1, R2>>>` Extracts two values of from each item in the iterable, allowing you to assert on a list of paris of those values. `fun <E, R1, R2, R3> Assert<Iterable<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2, f3: (E) -> R3): Assert<List<Triple<R1, R2, R3>>>` Extracts three values from each item in the iterable, allowing you to assert on a list of triples of those values.
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	`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. `fun <T : Any> Assert<T>.hasClass(jclass: Class<out T>): Unit` Asserts the value has the expected java class. This is an exact match, so `assertThat("test").hasClass(String::class.java)` is successful but `assertThat("test").hasClass(Any::class.java)` fails.
hasDirectChild	`fun Assert<File>.hasDirectChild(expected: File): Unit` Asserts the file has the expected direct child.
hasExtension	`fun Assert<File>.hasExtension(expected: String): Unit` Asserts the file has the expected extension.
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.
hasName	`fun Assert<File>.hasName(expected: String): Unit` Asserts the file has the expected name.
hasNoCause (Common)	`fun Assert<Throwable>.hasNoCause(): Unit` Asserts the throwable has no cause.
hasNotSameContentAs	`fun Assert<InputStream>.hasNotSameContentAs(expected: InputStream): Unit` Asserts that the actual stream has a different content as the expected stream. Both InputStreams will be closed by the assertion.
hasParent	`fun Assert<File>.hasParent(expected: String): Unit` Asserts the file has the expected parent path.
hasPath	`fun Assert<File>.hasPath(expected: String): Unit` Asserts the file has the expected path.
hasRootCause (Common)	`fun Assert<Throwable>.hasRootCause(cause: Throwable): Unit` Asserts the throwable is similar to the expected root cause, checking the type and message.
hasSameContentAs	`fun Assert<InputStream>.hasSameContentAs(expected: InputStream): Unit` Asserts that the actual stream has the same content as the expected stream. Both InputStreams will be closed by the assertion.
hasSameLengthAs (Common)	`fun Assert<CharSequence>.hasSameLengthAs(other: CharSequence): Unit` Asserts the char sequence has the same length as the expected one.
hasSameSizeAs	`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. `fun Assert<ByteArray>.hasSameSizeAs(other: ByteArray): Unit` Asserts the ByteArray has the same size as the expected array. `fun Assert<IntArray>.hasSameSizeAs(other: IntArray): Unit` Asserts the IntArray has the same size as the expected array. `fun Assert<ShortArray>.hasSameSizeAs(other: ShortArray): Unit` Asserts the ShortArray has the same size as the expected array. `fun Assert<LongArray>.hasSameSizeAs(other: LongArray): Unit` Asserts the LongArray has the same size as the expected array. `fun Assert<FloatArray>.hasSameSizeAs(other: FloatArray): Unit` Asserts the FloatArray has the same size as the expected array. `fun Assert<DoubleArray>.hasSameSizeAs(other: DoubleArray): Unit` Asserts the DoubleArray has the same size as the expected array. `fun Assert<CharArray>.hasSameSizeAs(other: CharArray): Unit` Asserts the CharArray has the same size as the expected array.
hasSize	`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. `fun Assert<ByteArray>.hasSize(size: Int): Unit` Asserts the ByteArray has the expected size. `fun Assert<IntArray>.hasSize(size: Int): Unit` Asserts the IntArray has the expected size. `fun Assert<ShortArray>.hasSize(size: Int): Unit` Asserts the ShortArray has the expected size. `fun Assert<LongArray>.hasSize(size: Int): Unit` Asserts the LongArray has the expected size. `fun Assert<FloatArray>.hasSize(size: Int): Unit` Asserts the FloatArray has the expected size. `fun Assert<DoubleArray>.hasSize(size: Int): Unit` Asserts the DoubleArray has the expected size. `fun Assert<CharArray>.hasSize(size: Int): Unit` Asserts the CharArray has the expected size.
hasText	`fun Assert<File>.hasText(expected: String, charset: Charset = Charsets.UTF_8): Unit` Asserts the file contains exactly the expected text (and nothing else).
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	`fun <T> Assert<Array<T>>.index(index: Int, f: (Assert<T>) -> Unit): Unit` `fun <T> Assert<Array<T>>.index(index: Int): Assert<T>` `fun Assert<ByteArray>.index(index: Int, f: (Assert<Byte>) -> Unit): Unit` `fun Assert<ByteArray>.index(index: Int): Assert<Byte>` `fun Assert<IntArray>.index(index: Int, f: (Assert<Int>) -> Unit): Unit` `fun Assert<IntArray>.index(index: Int): Assert<Int>` `fun Assert<ShortArray>.index(index: Int, f: (Assert<Short>) -> Unit): Unit` `fun Assert<ShortArray>.index(index: Int): Assert<Short>` `fun Assert<LongArray>.index(index: Int, f: (Assert<Long>) -> Unit): Unit` `fun Assert<LongArray>.index(index: Int): Assert<Long>` `fun Assert<FloatArray>.index(index: Int, f: (Assert<Float>) -> Unit): Unit` `fun Assert<FloatArray>.index(index: Int): Assert<Float>` `fun Assert<DoubleArray>.index(index: Int, f: (Assert<Double>) -> Unit): Unit` `fun Assert<DoubleArray>.index(index: Int): Assert<Double>` `fun Assert<CharArray>.index(index: Int, f: (Assert<Char>) -> Unit): Unit` `fun Assert<CharArray>.index(index: Int): Assert<Char>` 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.
isDataClassEqualTo	`fun <T : Any> Assert<T>.isDataClassEqualTo(expected: T): Unit` Like isEqualTo but reports exactly which properties differ. Only supports data classes. Note: you should not use this if your data class has a custom Any.equals since it can be misleading.
isDirectory	`fun Assert<File>.isDirectory(): Unit` Asserts the file is a directory. `fun Assert<Path>.isDirectory(vararg options: LinkOption): Unit` Assert that the path is a directory.
isEmpty	`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. `fun Assert<ByteArray>.isEmpty(): Unit` Asserts the ByteArray is empty. `fun Assert<IntArray>.isEmpty(): Unit` Asserts the IntArray is empty. `fun Assert<ShortArray>.isEmpty(): Unit` Asserts the ShortArray is empty. `fun Assert<LongArray>.isEmpty(): Unit` Asserts the LongArray is empty. `fun Assert<FloatArray>.isEmpty(): Unit` Asserts the FloatArray is empty. `fun Assert<DoubleArray>.isEmpty(): Unit` Asserts the DoubleArray is empty. `fun Assert<CharArray>.isEmpty(): Unit` Asserts the CharArray is empty.
isEqualTo	`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. `fun Assert<ByteArray>.isEqualTo(expected: ByteArray): Unit` Asserts the ByteArray contents are equal to the expected one, using contentDeepEquals. `fun Assert<IntArray>.isEqualTo(expected: IntArray): Unit` Asserts the IntArray contents are equal to the expected one, using contentDeepEquals. `fun Assert<ShortArray>.isEqualTo(expected: ShortArray): Unit` Asserts the ShortArray contents are equal to the expected one, using contentDeepEquals. `fun Assert<LongArray>.isEqualTo(expected: LongArray): Unit` Asserts the LongArray contents are equal to the expected one, using contentDeepEquals. `fun Assert<FloatArray>.isEqualTo(expected: FloatArray): Unit` Asserts the FloatArray contents are equal to the expected one, using contentDeepEquals. `fun Assert<DoubleArray>.isEqualTo(expected: DoubleArray): Unit` Asserts the DoubleArray contents are equal to the expected one, using contentDeepEquals. `fun Assert<CharArray>.isEqualTo(expected: CharArray): Unit` Asserts the CharArray contents are equal to the expected one, using contentDeepEquals.
isEqualToIgnoringGivenProperties	`fun <T : Any> Assert<T>.isEqualToIgnoringGivenProperties(other: T, vararg properties: KProperty1<T, Any>): Unit` Returns an assert that compares for all properties except the given properties on the calling class
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
isExecutable	`fun Assert<Path>.isExecutable(): Unit` Assert that the path is an executable.
isFailure (Common)	`fun <T> Assert<Result<T>>.isFailure(): Assert<Throwable>` Asserts the given assertk.Result threw an exception, returning that exception if it was or failing it if didn't.
isFalse (Common)	`fun Assert<Boolean>.isFalse(): Unit` Asserts the boolean is false.
isFile	`fun Assert<File>.isFile(): Unit` Asserts the file is a simple file (not a directory).
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 `>=`.
isHidden	`fun Assert<File>.isHidden(): Unit` Asserts the file is hidden. `fun Assert<Path>.isHidden(): Unit` Assert that the path is hidden.
isIn (Common)	`fun <T> Assert<T>.isIn(vararg values: T): Unit` Asserts the value is in the expected values, using `in`.
isInstanceOf	`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. `fun <T : Any, S : T> Assert<T>.isInstanceOf(jclass: Class<S>): Assert<S>` `fun <T : Any, S : T> Assert<T>.isInstanceOf(jclass: Class<S>, f: (Assert<S>) -> Unit): Unit` Asserts the value is an instance of the expected java class. Both `assertThat("test").isInstanceOf(String::class.java)` and `assertThat("test").isInstanceOf(Any::class.java)` 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	`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. `fun Assert<ByteArray>.isNotEmpty(): Unit` Asserts the ByteArray is not empty. `fun Assert<IntArray>.isNotEmpty(): Unit` Asserts the IntArray is not empty. `fun Assert<ShortArray>.isNotEmpty(): Unit` Asserts the ShortArray is not empty. `fun Assert<LongArray>.isNotEmpty(): Unit` Asserts the LongArray is not empty. `fun Assert<FloatArray>.isNotEmpty(): Unit` Asserts the FloatArray is not empty. `fun Assert<DoubleArray>.isNotEmpty(): Unit` Asserts the DoubleArray is not empty. `fun Assert<CharArray>.isNotEmpty(): Unit` Asserts the CharArray is not empty.
isNotEqualTo	`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. `fun Assert<ByteArray>.isNotEqualTo(expected: ByteArray): Unit` Asserts the ByteArray contents are not equal to the expected one, using contentDeepEquals. `fun Assert<IntArray>.isNotEqualTo(expected: IntArray): Unit` Asserts the IntArray contents are not equal to the expected one, using contentDeepEquals. `fun Assert<ShortArray>.isNotEqualTo(expected: ShortArray): Unit` Asserts the ShortArray contents are not equal to the expected one, using contentDeepEquals. `fun Assert<LongArray>.isNotEqualTo(expected: LongArray): Unit` Asserts the LongArray contents are not equal to the expected one, using contentDeepEquals. `fun Assert<FloatArray>.isNotEqualTo(expected: FloatArray): Unit` Asserts the FloatArray contents are not equal to the expected one, using contentDeepEquals. `fun Assert<DoubleArray>.isNotEqualTo(expected: DoubleArray): Unit` Asserts the DoubleArray contents are not equal to the expected one, using contentDeepEquals. `fun Assert<CharArray>.isNotEqualTo(expected: CharArray): Unit` Asserts the CharArray contents are not equal to the expected one, using contentDeepEquals.
isNotHidden	`fun Assert<File>.isNotHidden(): Unit` Asserts the file is not hidden.
isNotIn (Common)	`fun <T> Assert<T>.isNotIn(vararg values: T): Unit` Asserts the value is not in the expected values, using `!in`.
isNotInstanceOf	`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. `fun <T : Any> Assert<T>.isNotInstanceOf(jclass: Class<out T>): Unit` Asserts the value is not an instance of the expected java 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	`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. `fun Assert<ByteArray?>.isNullOrEmpty(): Unit` Asserts the ByteArray is null or empty. `fun Assert<IntArray?>.isNullOrEmpty(): Unit` Asserts the IntArray is null or empty. `fun Assert<ShortArray?>.isNullOrEmpty(): Unit` Asserts the ShortArray is null or empty. `fun Assert<LongArray?>.isNullOrEmpty(): Unit` Asserts the LongArray is null or empty. `fun Assert<FloatArray?>.isNullOrEmpty(): Unit` Asserts the FloatArray is null or empty. `fun Assert<DoubleArray?>.isNullOrEmpty(): Unit` Asserts the DoubleArray is null or empty. `fun Assert<CharArray?>.isNullOrEmpty(): Unit` Asserts the CharArray is null or empty.
isPositive (Common)	`fun <T : Number> Assert<T>.isPositive(): Unit` Asserts the number is greater than 0.
isReadable	`fun Assert<Path>.isReadable(): Unit` Assert that the path is readable.
isRegularFile	`fun Assert<Path>.isRegularFile(vararg options: LinkOption): Unit` Assert that the path is a regular file.
isSameAs (Common)	`fun <T> Assert<T>.isSameAs(expected: T): Unit` Asserts the value is the same as the expected one, using `===`.
isSameFileAs	`fun Assert<Path>.isSameFileAs(expected: Path): Unit` Assert that the path points to the same object as the other path.
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.
isSuccess (Common)	`fun <T> Assert<Result<T>>.isSuccess(): Assert<T>` Asserts the given assertk.Result successful returned a value, returning it's result if it did or failing if it didn't.
isSymbolicLink	`fun Assert<Path>.isSymbolicLink(): Unit` Assert that the path is a symbolic link.
isTrue (Common)	`fun Assert<Boolean>.isTrue(): Unit` Asserts the boolean is true.
isWritable	`fun Assert<Path>.isWritable(): Unit` Assert that the path is writable link.
isZero (Common)	`fun <T : Number> Assert<T>.isZero(): Unit` Asserts the number is 0.
jClass	`fun <T : Any> Assert<T>.jClass(): Assert<Class<out T>>` Returns an assert on the java class of the value.
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.
lines	`fun Assert<Path>.lines(charset: Charset = Charsets.UTF_8): Assert<List<String>>` Assert on file lines
matches (Common)	`fun Assert<String>.matches(regex: Regex): 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.
messageContains (Common)	`fun Assert<Throwable>.messageContains(text: String): Unit` Asserts the throwable contains the expected text
name	`fun Assert<File>.name(): Assert<String>` Returns an assert on the file's name.
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.
parent	`fun Assert<File>.parent(): Assert<String>` Returns an assert on the file's parent.
path	`fun Assert<File>.path(): Assert<String>` Returns an assert on the file's path.
prop	`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. `fun <T, P> Assert<T>.prop(callable: KCallable<P>): Assert<P>` Returns an assert that asserts on the given property.
returnedValue (Common)	`fun <T> Assert<Result<T>>.returnedValue(f: Assert<T>.() -> Unit): Unit` Runs the given lambda if the block returns a value, otherwise fails.
rootCause (Common)	`fun Assert<Throwable>.rootCause(): Assert<Throwable>` Returns an assert on the throwable's root cause.
size	`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. `fun Assert<ByteArray>.size(): Assert<Int>` Returns an assert on the ByteArray's size. `fun Assert<IntArray>.size(): Assert<Int>` Returns an assert on the IntArray's size. `fun Assert<ShortArray>.size(): Assert<Int>` Returns an assert on the ShortArray's size. `fun Assert<LongArray>.size(): Assert<Int>` Returns an assert on the LongArray's size. `fun Assert<FloatArray>.size(): Assert<Int>` Returns an assert on the FloatArray's size. `fun Assert<DoubleArray>.size(): Assert<Int>` Returns an assert on the DoubleArray's size. `fun Assert<CharArray>.size(): Assert<Int>` Returns an assert on the CharArray's size.
stackTrace	`fun Assert<Throwable>.stackTrace(): Assert<List<String>>` Returns an assert on the throwable's stack trace.
startsWith (Common)	`fun Assert<String>.startsWith(other: String, ignoreCase: Boolean = false): Unit` Asserts the string starts with the expected string.
text	`fun Assert<File>.text(charset: Charset = Charsets.UTF_8): Assert<String>` Returns an assert on the file's contents as text.
thrownError (Common)	`fun <T> Assert<Result<T>>.thrownError(f: Assert<Throwable>.() -> Unit): Unit` Runs the given lambda if the block throws an error, otherwise fails.
toStringFun (Common)	`fun <T> Assert<T>.toStringFun(): Assert<String>` Returns an assert on the toString method of the value.