assertk.assertions

Package assertk.assertions

Functions

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 <ERROR CLASS><File>.bytes(): <ERROR CLASS>` `fun Assert<File>.bytes(): Assert<ByteArray>` Returns an assert on the file's contents as bytes. `fun <ERROR CLASS><Path>.bytes(): <ERROR CLASS><ByteArray>` `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> <ERROR CLASS><T>.doesNotHaveClass(jclass: Class<out T>): <ERROR CLASS>` `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.
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 <ERROR CLASS><File>.exists(): <ERROR CLASS>` `fun Assert<File>.exists(): Unit` Asserts the file exists.
extension	`fun <ERROR CLASS><File>.extension(): <ERROR CLASS>` `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.
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> <ERROR CLASS><T>.hasClass(jclass: Class<out T>): <ERROR CLASS>` `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 <ERROR CLASS><File>.hasDirectChild(expected: File): <ERROR CLASS>` `fun Assert<File>.hasDirectChild(expected: File): Unit` Asserts the file has the expected direct child.
hasExtension	`fun <ERROR CLASS><File>.hasExtension(expected: String): Unit` `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 <ERROR CLASS><File>.hasName(expected: String): Unit` `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 <ERROR CLASS><InputStream>.hasNotSameContentAs(expected: InputStream): <ERROR CLASS>` `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 <ERROR CLASS><File>.hasParent(expected: String): Unit` `fun Assert<File>.hasParent(expected: String): Unit` Asserts the file has the expected parent path.
hasPath	`fun <ERROR CLASS><File>.hasPath(expected: String): Unit` `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 <ERROR CLASS><InputStream>.hasSameContentAs(expected: InputStream): <ERROR CLASS>` `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 <ERROR CLASS><File>.hasText(expected: String, charset: Charset = Charsets.UTF_8): Unit` `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> <ERROR CLASS><T>.isDataClassEqualTo(expected: T): <ERROR CLASS>` 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. `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 <ERROR CLASS><File>.isDirectory(): <ERROR CLASS>` `fun Assert<File>.isDirectory(): Unit` Asserts the file is a directory. `fun <ERROR CLASS><Path>.isDirectory(vararg options: LinkOption): <ERROR CLASS>` `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> <ERROR CLASS><T>.isEqualToIgnoringGivenProperties(other: T, vararg properties: KProperty1<T, Any>): Unit` `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 <ERROR CLASS><Path>.isExecutable(): <ERROR CLASS>` `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 <ERROR CLASS><File>.isFile(): <ERROR CLASS>` `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 <ERROR CLASS><File>.isHidden(): <ERROR CLASS>` `fun Assert<File>.isHidden(): Unit` Asserts the file is hidden. `fun <ERROR CLASS><Path>.isHidden(): <ERROR CLASS>` `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> <ERROR CLASS><T>.isInstanceOf(jclass: Class<S>): <ERROR CLASS><S>` `fun <T : Any, S : T> <ERROR CLASS><T>.isInstanceOf(jclass: Class<S>, f: (<ERROR CLASS><S>) -> Unit): Unit` `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 <ERROR CLASS><File>.isNotHidden(): <ERROR CLASS>` `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> <ERROR CLASS><T>.isNotInstanceOf(jclass: Class<out T>): <ERROR CLASS>` `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 <ERROR CLASS><Path>.isReadable(): <ERROR CLASS>` `fun Assert<Path>.isReadable(): Unit` Assert that the path is readable.
isRegularFile	`fun <ERROR CLASS><Path>.isRegularFile(vararg options: LinkOption): <ERROR CLASS>` `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 <ERROR CLASS><Path>.isSameFileAs(expected: Path): <ERROR CLASS>` `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 <ERROR CLASS><Path>.isSymbolicLink(): <ERROR CLASS>` `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 <ERROR CLASS><Path>.isWritable(): <ERROR CLASS>` `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> <ERROR CLASS><T>.jClass(): <ERROR CLASS>` `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 <ERROR CLASS><Path>.lines(charset: Charset = Charsets.UTF_8): <ERROR CLASS><List<String>>` `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 <ERROR CLASS><File>.name(): <ERROR CLASS>` `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 <ERROR CLASS><File>.parent(): <ERROR CLASS>` `fun Assert<File>.parent(): Assert<String>` Returns an assert on the file's parent.
path	`fun <ERROR CLASS><File>.path(): <ERROR CLASS>` `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> <ERROR CLASS><T>.prop(callable: KCallable<P>): <ERROR CLASS>` `fun <T, P> Assert<T>.prop(callable: KCallable<P>): Assert<P>` Returns an assert that asserts on the given property.
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 <ERROR CLASS><Throwable>.stackTrace(): <ERROR CLASS>` `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 <ERROR CLASS><File>.text(charset: Charset = Charsets.UTF_8): <ERROR CLASS>` `fun Assert<File>.text(charset: Charset = Charsets.UTF_8): Assert<String>` Returns an assert on the file's contents as text.
toStringFun (Common)	`fun <T> Assert<T>.toStringFun(): Assert<String>` Returns an assert on the toString method of the value.