assertk.assertions

Class PrimativeArrayKt

assertk.assertions.PrimativeArrayKt

public class PrimativeArrayKt

Method Summary

Modifier and Type	Method and Description
static void	byteArrayContains(Assert<kotlin.Array[]> $receiver, byte element) Asserts the ByteArray contains the expected element, using in.
static void	byteArrayContainsAll(Assert<kotlin.Array[]> $receiver, byte elements) Asserts the ByteArray contains all the expected elements, in any order. The array may also contain additional elements.
static void	byteArrayContainsExactly(Assert<kotlin.Array[]> $receiver, byte elements) Asserts the ByteArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.
static void	byteArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, byte element) Asserts the ByteArray does not contain the expected element, using !in.
static void	byteArrayEach(Assert<kotlin.Array[]> $receiver, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Byte>,kotlin.Unit> f) Asserts on each item in the ByteArray. The given lambda will be run for each item.
static void	byteArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, byte[] other) Asserts the ByteArray has the same size as the expected array.
static void	byteArrayHasSize(Assert<kotlin.Array[]> $receiver, int size) Asserts the ByteArray has the expected size.
static Assert<java.lang.Byte>	byteArrayIndex(Assert<kotlin.Array[]> $receiver, int index) Returns an assert that assertion on the value at the given index in the array.
static void	byteArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Byte>,kotlin.Unit> f) Deprecated.
static void	byteArrayIsEmpty(Assert<kotlin.Array[]> $receiver) Asserts the ByteArray is empty.
static void	byteArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver) Asserts the ByteArray is not empty.
static void	byteArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver) Asserts the ByteArray is null or empty.
static Assert<java.lang.Integer>	byteArraySize(Assert<kotlin.Array[]> $receiver) Returns an assert on the ByteArray's size.
static void	charArrayContains(Assert<kotlin.Array[]> $receiver, char element) Asserts the CharArray contains the expected element, using in.
static void	charArrayContainsAll(Assert<kotlin.Array[]> $receiver, char elements) Asserts the CharArray contains all the expected elements, in any order. The array may also contain additional elements.
static void	charArrayContainsExactly(Assert<kotlin.Array[]> $receiver, char elements) Asserts the CharArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.
static void	charArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, char element) Asserts the CharArray does not contain the expected element, using !in.
static void	charArrayEach(Assert<kotlin.Array[]> $receiver, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Character>,kotlin.Unit> f) Asserts on each item in the CharArray. The given lambda will be run for each item.
static void	charArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, char[] other) Asserts the CharArray has the same size as the expected array.
static void	charArrayHasSize(Assert<kotlin.Array[]> $receiver, int size) Asserts the CharArray has the expected size.
static Assert<java.lang.Character>	charArrayIndex(Assert<kotlin.Array[]> $receiver, int index) Returns an assert that assertion on the value at the given index in the array.
static void	charArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Character>,kotlin.Unit> f) Deprecated.
static void	charArrayIsEmpty(Assert<kotlin.Array[]> $receiver) Asserts the CharArray is empty.
static void	charArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver) Asserts the CharArray is not empty.
static void	charArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver) Asserts the CharArray is null or empty.
static Assert<java.lang.Integer>	charArraySize(Assert<kotlin.Array[]> $receiver) Returns an assert on the CharArray's size.
static void	containsNone(Assert<kotlin.Array[]> $receiver, byte elements) Asserts the ByteArray does not contain any of the expected elements.
static void	containsNone(Assert<kotlin.Array[]> $receiver, int elements) Asserts the IntArray does not contain any of the expected elements.
static void	containsNone(Assert<kotlin.Array[]> $receiver, short elements) Asserts the ShortArray does not contain any of the expected elements.
static void	containsNone(Assert<kotlin.Array[]> $receiver, long elements) Asserts the LongArray does not contain any of the expected elements.
static void	containsNone(Assert<kotlin.Array[]> $receiver, float elements) Asserts the FloatArray does not contain any of the expected elements.
static void	containsNone(Assert<kotlin.Array[]> $receiver, double elements) Asserts the DoubleArray does not contain any of the expected elements.
static void	containsNone(Assert<kotlin.Array[]> $receiver, char elements) Asserts the CharArray does not contain any of the expected elements.
static void	doubleArrayContains(Assert<kotlin.Array[]> $receiver, double element) Asserts the DoubleArray contains the expected element, using in.
static void	doubleArrayContainsAll(Assert<kotlin.Array[]> $receiver, double elements) Asserts the DoubleArray contains all the expected elements, in any order. The array may also contain additional elements.
static void	doubleArrayContainsExactly(Assert<kotlin.Array[]> $receiver, double elements) Asserts the DoubleArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.
static void	doubleArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, double element) Asserts the DoubleArray does not contain the expected element, using !in.
static void	doubleArrayEach(Assert<kotlin.Array[]> $receiver, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Double>,kotlin.Unit> f) Asserts on each item in the DoubleArray. The given lambda will be run for each item.
static void	doubleArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, double[] other) Asserts the DoubleArray has the same size as the expected array.
static void	doubleArrayHasSize(Assert<kotlin.Array[]> $receiver, int size) Asserts the DoubleArray has the expected size.
static Assert<java.lang.Double>	doubleArrayIndex(Assert<kotlin.Array[]> $receiver, int index) Returns an assert that assertion on the value at the given index in the array.
static void	doubleArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Double>,kotlin.Unit> f) Deprecated.
static void	doubleArrayIsEmpty(Assert<kotlin.Array[]> $receiver) Asserts the DoubleArray is empty.
static void	doubleArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver) Asserts the DoubleArray is not empty.
static void	doubleArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver) Asserts the DoubleArray is null or empty.
static Assert<java.lang.Integer>	doubleArraySize(Assert<kotlin.Array[]> $receiver) Returns an assert on the DoubleArray's size.
static void	floatArrayContains(Assert<kotlin.Array[]> $receiver, float element) Asserts the FloatArray contains the expected element, using in.
static void	floatArrayContainsAll(Assert<kotlin.Array[]> $receiver, float elements) Asserts the FloatArray contains all the expected elements, in any order. The array may also contain additional elements.
static void	floatArrayContainsExactly(Assert<kotlin.Array[]> $receiver, float elements) Asserts the FloatArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.
static void	floatArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, float element) Asserts the FloatArray does not contain the expected element, using !in.
static void	floatArrayEach(Assert<kotlin.Array[]> $receiver, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Float>,kotlin.Unit> f) Asserts on each item in the FloatArray. The given lambda will be run for each item.
static void	floatArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, float[] other) Asserts the FloatArray has the same size as the expected array.
static void	floatArrayHasSize(Assert<kotlin.Array[]> $receiver, int size) Asserts the FloatArray has the expected size.
static Assert<java.lang.Float>	floatArrayIndex(Assert<kotlin.Array[]> $receiver, int index) Returns an assert that assertion on the value at the given index in the array.
static void	floatArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Float>,kotlin.Unit> f) Deprecated.
static void	floatArrayIsEmpty(Assert<kotlin.Array[]> $receiver) Asserts the FloatArray is empty.
static void	floatArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver) Asserts the FloatArray is not empty.
static void	floatArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver) Asserts the FloatArray is null or empty.
static Assert<java.lang.Integer>	floatArraySize(Assert<kotlin.Array[]> $receiver) Returns an assert on the FloatArray's size.
static void	intArrayContains(Assert<kotlin.Array[]> $receiver, int element) Asserts the IntArray contains the expected element, using in.
static void	intArrayContainsAll(Assert<kotlin.Array[]> $receiver, int elements) Asserts the IntArray contains all the expected elements, in any order. The array may also contain additional elements.
static void	intArrayContainsExactly(Assert<kotlin.Array[]> $receiver, int elements) Asserts the IntArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.
static void	intArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, int element) Asserts the IntArray does not contain the expected element, using !in.
static void	intArrayEach(Assert<kotlin.Array[]> $receiver, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Integer>,kotlin.Unit> f) Asserts on each item in the IntArray. The given lambda will be run for each item.
static void	intArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, int[] other) Asserts the IntArray has the same size as the expected array.
static void	intArrayHasSize(Assert<kotlin.Array[]> $receiver, int size) Asserts the IntArray has the expected size.
static Assert<java.lang.Integer>	intArrayIndex(Assert<kotlin.Array[]> $receiver, int index) Returns an assert that assertion on the value at the given index in the array.
static void	intArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Integer>,kotlin.Unit> f) Deprecated.
static void	intArrayIsEmpty(Assert<kotlin.Array[]> $receiver) Asserts the IntArray is empty.
static void	intArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver) Asserts the IntArray is not empty.
static void	intArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver) Asserts the IntArray is null or empty.
static Assert<java.lang.Integer>	intArraySize(Assert<kotlin.Array[]> $receiver) Returns an assert on the IntArray's size.
static void	isEqualTo(Assert<kotlin.Array[]> $receiver, byte[] expected) Asserts the ByteArray contents are equal to the expected one, using contentDeepEquals.
static void	isEqualTo(Assert<kotlin.Array[]> $receiver, int[] expected) Asserts the IntArray contents are equal to the expected one, using contentDeepEquals.
static void	isEqualTo(Assert<kotlin.Array[]> $receiver, short[] expected) Asserts the ShortArray contents are equal to the expected one, using contentDeepEquals.
static void	isEqualTo(Assert<kotlin.Array[]> $receiver, long[] expected) Asserts the LongArray contents are equal to the expected one, using contentDeepEquals.
static void	isEqualTo(Assert<kotlin.Array[]> $receiver, float[] expected) Asserts the FloatArray contents are equal to the expected one, using contentDeepEquals.
static void	isEqualTo(Assert<kotlin.Array[]> $receiver, double[] expected) Asserts the DoubleArray contents are equal to the expected one, using contentDeepEquals.
static void	isEqualTo(Assert<kotlin.Array[]> $receiver, char[] expected) Asserts the CharArray contents are equal to the expected one, using contentDeepEquals.
static void	isNotEqualTo(Assert<kotlin.Array[]> $receiver, byte[] expected) Asserts the ByteArray contents are not equal to the expected one, using contentDeepEquals.
static void	isNotEqualTo(Assert<kotlin.Array[]> $receiver, int[] expected) Asserts the IntArray contents are not equal to the expected one, using contentDeepEquals.
static void	isNotEqualTo(Assert<kotlin.Array[]> $receiver, short[] expected) Asserts the ShortArray contents are not equal to the expected one, using contentDeepEquals.
static void	isNotEqualTo(Assert<kotlin.Array[]> $receiver, long[] expected) Asserts the LongArray contents are not equal to the expected one, using contentDeepEquals.
static void	isNotEqualTo(Assert<kotlin.Array[]> $receiver, float[] expected) Asserts the FloatArray contents are not equal to the expected one, using contentDeepEquals.
static void	isNotEqualTo(Assert<kotlin.Array[]> $receiver, double[] expected) Asserts the DoubleArray contents are not equal to the expected one, using contentDeepEquals.
static void	isNotEqualTo(Assert<kotlin.Array[]> $receiver, char[] expected) Asserts the CharArray contents are not equal to the expected one, using contentDeepEquals.
static void	longArrayContains(Assert<kotlin.Array[]> $receiver, long element) Asserts the LongArray contains the expected element, using in.
static void	longArrayContainsAll(Assert<kotlin.Array[]> $receiver, long elements) Asserts the LongArray contains all the expected elements, in any order. The array may also contain additional elements.
static void	longArrayContainsExactly(Assert<kotlin.Array[]> $receiver, long elements) Asserts the LongArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.
static void	longArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, long element) Asserts the LongArray does not contain the expected element, using !in.
static void	longArrayEach(Assert<kotlin.Array[]> $receiver, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Long>,kotlin.Unit> f) Asserts on each item in the LongArray. The given lambda will be run for each item.
static void	longArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, long[] other) Asserts the LongArray has the same size as the expected array.
static void	longArrayHasSize(Assert<kotlin.Array[]> $receiver, int size) Asserts the LongArray has the expected size.
static Assert<java.lang.Long>	longArrayIndex(Assert<kotlin.Array[]> $receiver, int index) Returns an assert that assertion on the value at the given index in the array.
static void	longArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Long>,kotlin.Unit> f) Deprecated.
static void	longArrayIsEmpty(Assert<kotlin.Array[]> $receiver) Asserts the LongArray is empty.
static void	longArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver) Asserts the LongArray is not empty.
static void	longArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver) Asserts the LongArray is null or empty.
static Assert<java.lang.Integer>	longArraySize(Assert<kotlin.Array[]> $receiver) Returns an assert on the LongArray's size.
static void	shortArrayContains(Assert<kotlin.Array[]> $receiver, short element) Asserts the ShortArray contains the expected element, using in.
static void	shortArrayContainsAll(Assert<kotlin.Array[]> $receiver, short elements) Asserts the ShortArray contains all the expected elements, in any order. The array may also contain additional elements.
static void	shortArrayContainsExactly(Assert<kotlin.Array[]> $receiver, short elements) Asserts the ShortArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.
static void	shortArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, short element) Asserts the ShortArray does not contain the expected element, using !in.
static void	shortArrayEach(Assert<kotlin.Array[]> $receiver, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Short>,kotlin.Unit> f) Asserts on each item in the ShortArray. The given lambda will be run for each item.
static void	shortArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, short[] other) Asserts the ShortArray has the same size as the expected array.
static void	shortArrayHasSize(Assert<kotlin.Array[]> $receiver, int size) Asserts the ShortArray has the expected size.
static Assert<java.lang.Short>	shortArrayIndex(Assert<kotlin.Array[]> $receiver, int index) Returns an assert that assertion on the value at the given index in the array.
static void	shortArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Short>,kotlin.Unit> f) Deprecated.
static void	shortArrayIsEmpty(Assert<kotlin.Array[]> $receiver) Asserts the ShortArray is empty.
static void	shortArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver) Asserts the ShortArray is not empty.
static void	shortArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver) Asserts the ShortArray is null or empty.
static Assert<java.lang.Integer>	shortArraySize(Assert<kotlin.Array[]> $receiver) Returns an assert on the ShortArray's size.

Method Detail

byteArraySize

public static Assert<java.lang.Integer> byteArraySize(Assert<kotlin.Array[]> $receiver)

Returns an assert on the ByteArray's size.

isEqualTo

public static void isEqualTo(Assert<kotlin.Array[]> $receiver,
                             byte[] expected)

Asserts the ByteArray contents are equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isNotEqualTo

isNotEqualTo

public static void isNotEqualTo(Assert<kotlin.Array[]> $receiver,
                                byte[] expected)

Asserts the ByteArray contents are not equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isEqualTo

byteArrayIsEmpty

public static void byteArrayIsEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the ByteArray is empty.

See Also:

PrimativeArrayKt.byteArrayIsNotEmpty, PrimativeArrayKt.byteArrayIsNullOrEmpty

byteArrayIsNotEmpty

public static void byteArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the ByteArray is not empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

byteArrayIsNullOrEmpty

public static void byteArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the ByteArray is null or empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

byteArrayHasSize

public static void byteArrayHasSize(Assert<kotlin.Array[]> $receiver,
                                    int size)

Asserts the ByteArray has the expected size.

byteArrayHasSameSizeAs

public static void byteArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver,
                                          byte[] other)

Asserts the ByteArray has the same size as the expected array.

byteArrayContains

public static void byteArrayContains(Assert<kotlin.Array[]> $receiver,
                                     byte element)

Asserts the ByteArray contains the expected element, using in.

See Also:

PrimativeArrayKt.byteArrayDoesNotContain

byteArrayDoesNotContain

public static void byteArrayDoesNotContain(Assert<kotlin.Array[]> $receiver,
                                           byte element)

Asserts the ByteArray does not contain the expected element, using !in.

See Also:

PrimativeArrayKt.byteArrayContains

containsNone

public static void containsNone(Assert<kotlin.Array[]> $receiver,
                                byte elements)

Asserts the ByteArray does not contain any of the expected elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

byteArrayContainsAll

public static void byteArrayContainsAll(Assert<kotlin.Array[]> $receiver,
                                        byte elements)

Asserts the ByteArray contains all the expected elements, in any order. The array may also contain additional elements.

See Also:

PrimativeArrayKt.byteArrayContainsExactly

byteArrayIndexOld

public static void byteArrayIndexOld(Assert<kotlin.Array[]> $receiver,
                                     int index,
                                     kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Byte>,kotlin.Unit> f)

Deprecated.

Returns an assert that assertion on the value at the given index in the array.

assertThat(byteArrayOf(0, 1, 2)).index(1) { it.isPositive() }

byteArrayIndex

public static Assert<java.lang.Byte> byteArrayIndex(Assert<kotlin.Array[]> $receiver,
                                                    int index)

Returns an assert that assertion on the value at the given index in the array.

assertThat(byteArrayOf(0, 1, 2)).index(1).isPositive()

byteArrayContainsExactly

public static void byteArrayContainsExactly(Assert<kotlin.Array[]> $receiver,
                                            byte elements)

Asserts the ByteArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

byteArrayEach

public static void byteArrayEach(Assert<kotlin.Array[]> $receiver,
                                 kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Byte>,kotlin.Unit> f)

Asserts on each item in the ByteArray. The given lambda will be run for each item.

assertThat(byteArrayOf("one", "two")).each {
  it.hasLength(3)
}

intArraySize

public static Assert<java.lang.Integer> intArraySize(Assert<kotlin.Array[]> $receiver)

Returns an assert on the IntArray's size.

isEqualTo

public static void isEqualTo(Assert<kotlin.Array[]> $receiver,
                             int[] expected)

Asserts the IntArray contents are equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isNotEqualTo

isNotEqualTo

public static void isNotEqualTo(Assert<kotlin.Array[]> $receiver,
                                int[] expected)

Asserts the IntArray contents are not equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isEqualTo

intArrayIsEmpty

public static void intArrayIsEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the IntArray is empty.

See Also:

PrimativeArrayKt.byteArrayIsNotEmpty, PrimativeArrayKt.byteArrayIsNullOrEmpty

intArrayIsNotEmpty

public static void intArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the IntArray is not empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

intArrayIsNullOrEmpty

public static void intArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the IntArray is null or empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

intArrayHasSize

public static void intArrayHasSize(Assert<kotlin.Array[]> $receiver,
                                   int size)

Asserts the IntArray has the expected size.

intArrayHasSameSizeAs

public static void intArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver,
                                         int[] other)

Asserts the IntArray has the same size as the expected array.

intArrayContains

public static void intArrayContains(Assert<kotlin.Array[]> $receiver,
                                    int element)

Asserts the IntArray contains the expected element, using in.

See Also:

PrimativeArrayKt.byteArrayDoesNotContain

intArrayDoesNotContain

public static void intArrayDoesNotContain(Assert<kotlin.Array[]> $receiver,
                                          int element)

Asserts the IntArray does not contain the expected element, using !in.

See Also:

PrimativeArrayKt.byteArrayContains

containsNone

public static void containsNone(Assert<kotlin.Array[]> $receiver,
                                int elements)

Asserts the IntArray does not contain any of the expected elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

intArrayContainsAll

public static void intArrayContainsAll(Assert<kotlin.Array[]> $receiver,
                                       int elements)

Asserts the IntArray contains all the expected elements, in any order. The array may also contain additional elements.

See Also:

PrimativeArrayKt.byteArrayContainsExactly

intArrayIndexOld

public static void intArrayIndexOld(Assert<kotlin.Array[]> $receiver,
                                    int index,
                                    kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Integer>,kotlin.Unit> f)

Deprecated.

Returns an assert that assertion on the value at the given index in the array.

assertThat(intArrayOf(0, 1, 2)).index(1) { it.isPositive() }

intArrayIndex

public static Assert<java.lang.Integer> intArrayIndex(Assert<kotlin.Array[]> $receiver,
                                                      int index)

Returns an assert that assertion on the value at the given index in the array.

assertThat(intArrayOf(0, 1, 2)).index(1).isPositive()

intArrayContainsExactly

public static void intArrayContainsExactly(Assert<kotlin.Array[]> $receiver,
                                           int elements)

Asserts the IntArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

intArrayEach

public static void intArrayEach(Assert<kotlin.Array[]> $receiver,
                                kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Integer>,kotlin.Unit> f)

Asserts on each item in the IntArray. The given lambda will be run for each item.

assertThat(intArrayOf("one", "two")).each {
  it.hasLength(3)
}

shortArraySize

public static Assert<java.lang.Integer> shortArraySize(Assert<kotlin.Array[]> $receiver)

Returns an assert on the ShortArray's size.

isEqualTo

public static void isEqualTo(Assert<kotlin.Array[]> $receiver,
                             short[] expected)

Asserts the ShortArray contents are equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isNotEqualTo

isNotEqualTo

public static void isNotEqualTo(Assert<kotlin.Array[]> $receiver,
                                short[] expected)

Asserts the ShortArray contents are not equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isEqualTo

shortArrayIsEmpty

public static void shortArrayIsEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the ShortArray is empty.

See Also:

PrimativeArrayKt.byteArrayIsNotEmpty, PrimativeArrayKt.byteArrayIsNullOrEmpty

shortArrayIsNotEmpty

public static void shortArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the ShortArray is not empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

shortArrayIsNullOrEmpty

public static void shortArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the ShortArray is null or empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

shortArrayHasSize

public static void shortArrayHasSize(Assert<kotlin.Array[]> $receiver,
                                     int size)

Asserts the ShortArray has the expected size.

shortArrayHasSameSizeAs

public static void shortArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver,
                                           short[] other)

Asserts the ShortArray has the same size as the expected array.

shortArrayContains

public static void shortArrayContains(Assert<kotlin.Array[]> $receiver,
                                      short element)

Asserts the ShortArray contains the expected element, using in.

See Also:

PrimativeArrayKt.byteArrayDoesNotContain

shortArrayDoesNotContain

public static void shortArrayDoesNotContain(Assert<kotlin.Array[]> $receiver,
                                            short element)

Asserts the ShortArray does not contain the expected element, using !in.

See Also:

PrimativeArrayKt.byteArrayContains

containsNone

public static void containsNone(Assert<kotlin.Array[]> $receiver,
                                short elements)

Asserts the ShortArray does not contain any of the expected elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

shortArrayContainsAll

public static void shortArrayContainsAll(Assert<kotlin.Array[]> $receiver,
                                         short elements)

Asserts the ShortArray contains all the expected elements, in any order. The array may also contain additional elements.

See Also:

PrimativeArrayKt.byteArrayContainsExactly

shortArrayIndexOld

public static void shortArrayIndexOld(Assert<kotlin.Array[]> $receiver,
                                      int index,
                                      kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Short>,kotlin.Unit> f)

Deprecated.

Returns an assert that assertion on the value at the given index in the array.

assertThat(shortArrayOf(0, 1, 2)).index(1) { it.isPositive() }

shortArrayIndex

public static Assert<java.lang.Short> shortArrayIndex(Assert<kotlin.Array[]> $receiver,
                                                      int index)

Returns an assert that assertion on the value at the given index in the array.

assertThat(shortArrayOf(0, 1, 2)).index(1).isPositive()

shortArrayContainsExactly

public static void shortArrayContainsExactly(Assert<kotlin.Array[]> $receiver,
                                             short elements)

Asserts the ShortArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

shortArrayEach

public static void shortArrayEach(Assert<kotlin.Array[]> $receiver,
                                  kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Short>,kotlin.Unit> f)

Asserts on each item in the ShortArray. The given lambda will be run for each item.

assertThat(shortArrayOf("one", "two")).each {
  it.hasLength(3)
}

longArraySize

public static Assert<java.lang.Integer> longArraySize(Assert<kotlin.Array[]> $receiver)

Returns an assert on the LongArray's size.

isEqualTo

public static void isEqualTo(Assert<kotlin.Array[]> $receiver,
                             long[] expected)

Asserts the LongArray contents are equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isNotEqualTo

isNotEqualTo

public static void isNotEqualTo(Assert<kotlin.Array[]> $receiver,
                                long[] expected)

Asserts the LongArray contents are not equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isEqualTo

longArrayIsEmpty

public static void longArrayIsEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the LongArray is empty.

See Also:

PrimativeArrayKt.byteArrayIsNotEmpty, PrimativeArrayKt.byteArrayIsNullOrEmpty

longArrayIsNotEmpty

public static void longArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the LongArray is not empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

longArrayIsNullOrEmpty

public static void longArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the LongArray is null or empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

longArrayHasSize

public static void longArrayHasSize(Assert<kotlin.Array[]> $receiver,
                                    int size)

Asserts the LongArray has the expected size.

longArrayHasSameSizeAs

public static void longArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver,
                                          long[] other)

Asserts the LongArray has the same size as the expected array.

longArrayContains

public static void longArrayContains(Assert<kotlin.Array[]> $receiver,
                                     long element)

Asserts the LongArray contains the expected element, using in.

See Also:

PrimativeArrayKt.byteArrayDoesNotContain

longArrayDoesNotContain

public static void longArrayDoesNotContain(Assert<kotlin.Array[]> $receiver,
                                           long element)

Asserts the LongArray does not contain the expected element, using !in.

See Also:

PrimativeArrayKt.byteArrayContains

containsNone

public static void containsNone(Assert<kotlin.Array[]> $receiver,
                                long elements)

Asserts the LongArray does not contain any of the expected elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

longArrayContainsAll

public static void longArrayContainsAll(Assert<kotlin.Array[]> $receiver,
                                        long elements)

Asserts the LongArray contains all the expected elements, in any order. The array may also contain additional elements.

See Also:

PrimativeArrayKt.byteArrayContainsExactly

longArrayIndexOld

public static void longArrayIndexOld(Assert<kotlin.Array[]> $receiver,
                                     int index,
                                     kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Long>,kotlin.Unit> f)

Deprecated.

Returns an assert that assertion on the value at the given index in the array.

assertThat(longArrayOf(0, 1, 2)).index(1) { it.isPositive() }

longArrayIndex

public static Assert<java.lang.Long> longArrayIndex(Assert<kotlin.Array[]> $receiver,
                                                    int index)

Returns an assert that assertion on the value at the given index in the array.

assertThat(longArrayOf(0, 1, 2)).index(1).isPositive()

longArrayContainsExactly

public static void longArrayContainsExactly(Assert<kotlin.Array[]> $receiver,
                                            long elements)

Asserts the LongArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

longArrayEach

public static void longArrayEach(Assert<kotlin.Array[]> $receiver,
                                 kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Long>,kotlin.Unit> f)

Asserts on each item in the LongArray. The given lambda will be run for each item.

assertThat(longArrayOf("one", "two")).each {
  it.hasLength(3)
}

floatArraySize

public static Assert<java.lang.Integer> floatArraySize(Assert<kotlin.Array[]> $receiver)

Returns an assert on the FloatArray's size.

isEqualTo

public static void isEqualTo(Assert<kotlin.Array[]> $receiver,
                             float[] expected)

Asserts the FloatArray contents are equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isNotEqualTo

isNotEqualTo

public static void isNotEqualTo(Assert<kotlin.Array[]> $receiver,
                                float[] expected)

Asserts the FloatArray contents are not equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isEqualTo

floatArrayIsEmpty

public static void floatArrayIsEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the FloatArray is empty.

See Also:

PrimativeArrayKt.byteArrayIsNotEmpty, PrimativeArrayKt.byteArrayIsNullOrEmpty

floatArrayIsNotEmpty

public static void floatArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the FloatArray is not empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

floatArrayIsNullOrEmpty

public static void floatArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the FloatArray is null or empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

floatArrayHasSize

public static void floatArrayHasSize(Assert<kotlin.Array[]> $receiver,
                                     int size)

Asserts the FloatArray has the expected size.

floatArrayHasSameSizeAs

public static void floatArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver,
                                           float[] other)

Asserts the FloatArray has the same size as the expected array.

floatArrayContains

public static void floatArrayContains(Assert<kotlin.Array[]> $receiver,
                                      float element)

Asserts the FloatArray contains the expected element, using in.

See Also:

PrimativeArrayKt.byteArrayDoesNotContain

floatArrayDoesNotContain

public static void floatArrayDoesNotContain(Assert<kotlin.Array[]> $receiver,
                                            float element)

Asserts the FloatArray does not contain the expected element, using !in.

See Also:

PrimativeArrayKt.byteArrayContains

containsNone

public static void containsNone(Assert<kotlin.Array[]> $receiver,
                                float elements)

Asserts the FloatArray does not contain any of the expected elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

floatArrayContainsAll

public static void floatArrayContainsAll(Assert<kotlin.Array[]> $receiver,
                                         float elements)

Asserts the FloatArray contains all the expected elements, in any order. The array may also contain additional elements.

See Also:

PrimativeArrayKt.byteArrayContainsExactly

floatArrayIndexOld

public static void floatArrayIndexOld(Assert<kotlin.Array[]> $receiver,
                                      int index,
                                      kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Float>,kotlin.Unit> f)

Deprecated.

Returns an assert that assertion on the value at the given index in the array.

assertThat(floatArrayOf(0, 1, 2)).index(1) { it.isPositive() }

floatArrayIndex

public static Assert<java.lang.Float> floatArrayIndex(Assert<kotlin.Array[]> $receiver,
                                                      int index)

Returns an assert that assertion on the value at the given index in the array.

assertThat(floatArrayOf(0, 1, 2)).index(1).isPositive()

floatArrayContainsExactly

public static void floatArrayContainsExactly(Assert<kotlin.Array[]> $receiver,
                                             float elements)

Asserts the FloatArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

floatArrayEach

public static void floatArrayEach(Assert<kotlin.Array[]> $receiver,
                                  kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Float>,kotlin.Unit> f)

Asserts on each item in the FloatArray. The given lambda will be run for each item.

assertThat(floatArrayOf("one", "two")).each {
  it.hasLength(3)
}

doubleArraySize

public static Assert<java.lang.Integer> doubleArraySize(Assert<kotlin.Array[]> $receiver)

Returns an assert on the DoubleArray's size.

isEqualTo

public static void isEqualTo(Assert<kotlin.Array[]> $receiver,
                             double[] expected)

Asserts the DoubleArray contents are equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isNotEqualTo

isNotEqualTo

public static void isNotEqualTo(Assert<kotlin.Array[]> $receiver,
                                double[] expected)

Asserts the DoubleArray contents are not equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isEqualTo

doubleArrayIsEmpty

public static void doubleArrayIsEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the DoubleArray is empty.

See Also:

PrimativeArrayKt.byteArrayIsNotEmpty, PrimativeArrayKt.byteArrayIsNullOrEmpty

doubleArrayIsNotEmpty

public static void doubleArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the DoubleArray is not empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

doubleArrayIsNullOrEmpty

public static void doubleArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the DoubleArray is null or empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

doubleArrayHasSize

public static void doubleArrayHasSize(Assert<kotlin.Array[]> $receiver,
                                      int size)

Asserts the DoubleArray has the expected size.

doubleArrayHasSameSizeAs

public static void doubleArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver,
                                            double[] other)

Asserts the DoubleArray has the same size as the expected array.

doubleArrayContains

public static void doubleArrayContains(Assert<kotlin.Array[]> $receiver,
                                       double element)

Asserts the DoubleArray contains the expected element, using in.

See Also:

PrimativeArrayKt.byteArrayDoesNotContain

doubleArrayDoesNotContain

public static void doubleArrayDoesNotContain(Assert<kotlin.Array[]> $receiver,
                                             double element)

Asserts the DoubleArray does not contain the expected element, using !in.

See Also:

PrimativeArrayKt.byteArrayContains

containsNone

public static void containsNone(Assert<kotlin.Array[]> $receiver,
                                double elements)

Asserts the DoubleArray does not contain any of the expected elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

doubleArrayContainsAll

public static void doubleArrayContainsAll(Assert<kotlin.Array[]> $receiver,
                                          double elements)

Asserts the DoubleArray contains all the expected elements, in any order. The array may also contain additional elements.

See Also:

PrimativeArrayKt.byteArrayContainsExactly

doubleArrayIndexOld

public static void doubleArrayIndexOld(Assert<kotlin.Array[]> $receiver,
                                       int index,
                                       kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Double>,kotlin.Unit> f)

Deprecated.

Returns an assert that assertion on the value at the given index in the array.

assertThat(doubleArrayOf(0, 1, 2)).index(1) { it.isPositive() }

doubleArrayIndex

public static Assert<java.lang.Double> doubleArrayIndex(Assert<kotlin.Array[]> $receiver,
                                                        int index)

Returns an assert that assertion on the value at the given index in the array.

assertThat(doubleArrayOf(0, 1, 2)).index(1).isPositive()

doubleArrayContainsExactly

public static void doubleArrayContainsExactly(Assert<kotlin.Array[]> $receiver,
                                              double elements)

Asserts the DoubleArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

doubleArrayEach

public static void doubleArrayEach(Assert<kotlin.Array[]> $receiver,
                                   kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Double>,kotlin.Unit> f)

Asserts on each item in the DoubleArray. The given lambda will be run for each item.

assertThat(doubleArrayOf("one", "two")).each {
  it.hasLength(3)
}

charArraySize

public static Assert<java.lang.Integer> charArraySize(Assert<kotlin.Array[]> $receiver)

Returns an assert on the CharArray's size.

isEqualTo

public static void isEqualTo(Assert<kotlin.Array[]> $receiver,
                             char[] expected)

Asserts the CharArray contents are equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isNotEqualTo

isNotEqualTo

public static void isNotEqualTo(Assert<kotlin.Array[]> $receiver,
                                char[] expected)

Asserts the CharArray contents are not equal to the expected one, using contentDeepEquals.

See Also:

contentDeepEquals, PrimativeArrayKt.isEqualTo

charArrayIsEmpty

public static void charArrayIsEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the CharArray is empty.

See Also:

PrimativeArrayKt.byteArrayIsNotEmpty, PrimativeArrayKt.byteArrayIsNullOrEmpty

charArrayIsNotEmpty

public static void charArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the CharArray is not empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

charArrayIsNullOrEmpty

public static void charArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)

Asserts the CharArray is null or empty.

See Also:

PrimativeArrayKt.byteArrayIsEmpty

charArrayHasSize

public static void charArrayHasSize(Assert<kotlin.Array[]> $receiver,
                                    int size)

Asserts the CharArray has the expected size.

charArrayHasSameSizeAs

public static void charArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver,
                                          char[] other)

Asserts the CharArray has the same size as the expected array.

charArrayContains

public static void charArrayContains(Assert<kotlin.Array[]> $receiver,
                                     char element)

Asserts the CharArray contains the expected element, using in.

See Also:

PrimativeArrayKt.byteArrayDoesNotContain

charArrayDoesNotContain

public static void charArrayDoesNotContain(Assert<kotlin.Array[]> $receiver,
                                           char element)

Asserts the CharArray does not contain the expected element, using !in.

See Also:

PrimativeArrayKt.byteArrayContains

containsNone

public static void containsNone(Assert<kotlin.Array[]> $receiver,
                                char elements)

Asserts the CharArray does not contain any of the expected elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

charArrayContainsAll

public static void charArrayContainsAll(Assert<kotlin.Array[]> $receiver,
                                        char elements)

Asserts the CharArray contains all the expected elements, in any order. The array may also contain additional elements.

See Also:

PrimativeArrayKt.byteArrayContainsExactly

charArrayIndexOld

public static void charArrayIndexOld(Assert<kotlin.Array[]> $receiver,
                                     int index,
                                     kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Character>,kotlin.Unit> f)

Deprecated.

Returns an assert that assertion on the value at the given index in the array.

assertThat(charArrayOf(0, 1, 2)).index(1) { it.isPositive() }

charArrayIndex

public static Assert<java.lang.Character> charArrayIndex(Assert<kotlin.Array[]> $receiver,
                                                         int index)

Returns an assert that assertion on the value at the given index in the array.

assertThat(charArrayOf(0, 1, 2)).index(1).isPositive()

charArrayContainsExactly

public static void charArrayContainsExactly(Assert<kotlin.Array[]> $receiver,
                                            char elements)

Asserts the CharArray contains exactly the expected elements. They must be in the same order and there must not be any extra elements.

See Also:

PrimativeArrayKt.byteArrayContainsAll

charArrayEach

public static void charArrayEach(Assert<kotlin.Array[]> $receiver,
                                 kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Character>,kotlin.Unit> f)

Asserts on each item in the CharArray. The given lambda will be run for each item.

assertThat(charArrayOf("one", "two")).each {
  it.hasLength(3)
}