public class PrimativeArrayKt
| 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.
|
public static Assert<java.lang.Integer> byteArraySize(Assert<kotlin.Array[]> $receiver)
Returns an assert on the ByteArray's size.
public static void isEqualTo(Assert<kotlin.Array[]> $receiver, byte[] expected)
Asserts the ByteArray contents are equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isNotEqualTopublic static void isNotEqualTo(Assert<kotlin.Array[]> $receiver, byte[] expected)
Asserts the ByteArray contents are not equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isEqualTopublic static void byteArrayIsEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the ByteArray is empty.
public static void byteArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the ByteArray is not empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void byteArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the ByteArray is null or empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void byteArrayHasSize(Assert<kotlin.Array[]> $receiver, int size)
Asserts the ByteArray has the expected size.
public static void byteArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, byte[] other)
Asserts the ByteArray has the same size as the expected array.
public static void byteArrayContains(Assert<kotlin.Array[]> $receiver, byte element)
Asserts the ByteArray contains the expected element, using in.
PrimativeArrayKt.byteArrayDoesNotContainpublic static void byteArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, byte element)
Asserts the ByteArray does not contain the expected element, using !in.
PrimativeArrayKt.byteArrayContainspublic static void containsNone(Assert<kotlin.Array[]> $receiver, byte elements)
Asserts the ByteArray does not contain any of the expected elements.
PrimativeArrayKt.byteArrayContainsAllpublic 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.
public static void byteArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Byte>,kotlin.Unit> f)
Returns an assert that assertion on the value at the given index in the array.
assertThat(byteArrayOf(0, 1, 2)).index(1) { it.isPositive() }
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()
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.
PrimativeArrayKt.byteArrayContainsAllpublic 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)
}
public static Assert<java.lang.Integer> intArraySize(Assert<kotlin.Array[]> $receiver)
Returns an assert on the IntArray's size.
public static void isEqualTo(Assert<kotlin.Array[]> $receiver, int[] expected)
Asserts the IntArray contents are equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isNotEqualTopublic static void isNotEqualTo(Assert<kotlin.Array[]> $receiver, int[] expected)
Asserts the IntArray contents are not equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isEqualTopublic static void intArrayIsEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the IntArray is empty.
public static void intArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the IntArray is not empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void intArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the IntArray is null or empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void intArrayHasSize(Assert<kotlin.Array[]> $receiver, int size)
Asserts the IntArray has the expected size.
public static void intArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, int[] other)
Asserts the IntArray has the same size as the expected array.
public static void intArrayContains(Assert<kotlin.Array[]> $receiver, int element)
Asserts the IntArray contains the expected element, using in.
PrimativeArrayKt.byteArrayDoesNotContainpublic static void intArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, int element)
Asserts the IntArray does not contain the expected element, using !in.
PrimativeArrayKt.byteArrayContainspublic static void containsNone(Assert<kotlin.Array[]> $receiver, int elements)
Asserts the IntArray does not contain any of the expected elements.
PrimativeArrayKt.byteArrayContainsAllpublic 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.
public static void intArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Integer>,kotlin.Unit> f)
Returns an assert that assertion on the value at the given index in the array.
assertThat(intArrayOf(0, 1, 2)).index(1) { it.isPositive() }
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()
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.
PrimativeArrayKt.byteArrayContainsAllpublic 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)
}
public static Assert<java.lang.Integer> shortArraySize(Assert<kotlin.Array[]> $receiver)
Returns an assert on the ShortArray's size.
public static void isEqualTo(Assert<kotlin.Array[]> $receiver, short[] expected)
Asserts the ShortArray contents are equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isNotEqualTopublic static void isNotEqualTo(Assert<kotlin.Array[]> $receiver, short[] expected)
Asserts the ShortArray contents are not equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isEqualTopublic static void shortArrayIsEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the ShortArray is empty.
public static void shortArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the ShortArray is not empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void shortArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the ShortArray is null or empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void shortArrayHasSize(Assert<kotlin.Array[]> $receiver, int size)
Asserts the ShortArray has the expected size.
public static void shortArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, short[] other)
Asserts the ShortArray has the same size as the expected array.
public static void shortArrayContains(Assert<kotlin.Array[]> $receiver, short element)
Asserts the ShortArray contains the expected element, using in.
PrimativeArrayKt.byteArrayDoesNotContainpublic static void shortArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, short element)
Asserts the ShortArray does not contain the expected element, using !in.
PrimativeArrayKt.byteArrayContainspublic static void containsNone(Assert<kotlin.Array[]> $receiver, short elements)
Asserts the ShortArray does not contain any of the expected elements.
PrimativeArrayKt.byteArrayContainsAllpublic 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.
public static void shortArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Short>,kotlin.Unit> f)
Returns an assert that assertion on the value at the given index in the array.
assertThat(shortArrayOf(0, 1, 2)).index(1) { it.isPositive() }
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()
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.
PrimativeArrayKt.byteArrayContainsAllpublic 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)
}
public static Assert<java.lang.Integer> longArraySize(Assert<kotlin.Array[]> $receiver)
Returns an assert on the LongArray's size.
public static void isEqualTo(Assert<kotlin.Array[]> $receiver, long[] expected)
Asserts the LongArray contents are equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isNotEqualTopublic static void isNotEqualTo(Assert<kotlin.Array[]> $receiver, long[] expected)
Asserts the LongArray contents are not equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isEqualTopublic static void longArrayIsEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the LongArray is empty.
public static void longArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the LongArray is not empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void longArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the LongArray is null or empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void longArrayHasSize(Assert<kotlin.Array[]> $receiver, int size)
Asserts the LongArray has the expected size.
public static void longArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, long[] other)
Asserts the LongArray has the same size as the expected array.
public static void longArrayContains(Assert<kotlin.Array[]> $receiver, long element)
Asserts the LongArray contains the expected element, using in.
PrimativeArrayKt.byteArrayDoesNotContainpublic static void longArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, long element)
Asserts the LongArray does not contain the expected element, using !in.
PrimativeArrayKt.byteArrayContainspublic static void containsNone(Assert<kotlin.Array[]> $receiver, long elements)
Asserts the LongArray does not contain any of the expected elements.
PrimativeArrayKt.byteArrayContainsAllpublic 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.
public static void longArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Long>,kotlin.Unit> f)
Returns an assert that assertion on the value at the given index in the array.
assertThat(longArrayOf(0, 1, 2)).index(1) { it.isPositive() }
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()
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.
PrimativeArrayKt.byteArrayContainsAllpublic 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)
}
public static Assert<java.lang.Integer> floatArraySize(Assert<kotlin.Array[]> $receiver)
Returns an assert on the FloatArray's size.
public static void isEqualTo(Assert<kotlin.Array[]> $receiver, float[] expected)
Asserts the FloatArray contents are equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isNotEqualTopublic static void isNotEqualTo(Assert<kotlin.Array[]> $receiver, float[] expected)
Asserts the FloatArray contents are not equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isEqualTopublic static void floatArrayIsEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the FloatArray is empty.
public static void floatArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the FloatArray is not empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void floatArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the FloatArray is null or empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void floatArrayHasSize(Assert<kotlin.Array[]> $receiver, int size)
Asserts the FloatArray has the expected size.
public static void floatArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, float[] other)
Asserts the FloatArray has the same size as the expected array.
public static void floatArrayContains(Assert<kotlin.Array[]> $receiver, float element)
Asserts the FloatArray contains the expected element, using in.
PrimativeArrayKt.byteArrayDoesNotContainpublic static void floatArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, float element)
Asserts the FloatArray does not contain the expected element, using !in.
PrimativeArrayKt.byteArrayContainspublic static void containsNone(Assert<kotlin.Array[]> $receiver, float elements)
Asserts the FloatArray does not contain any of the expected elements.
PrimativeArrayKt.byteArrayContainsAllpublic 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.
public static void floatArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Float>,kotlin.Unit> f)
Returns an assert that assertion on the value at the given index in the array.
assertThat(floatArrayOf(0, 1, 2)).index(1) { it.isPositive() }
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()
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.
PrimativeArrayKt.byteArrayContainsAllpublic 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)
}
public static Assert<java.lang.Integer> doubleArraySize(Assert<kotlin.Array[]> $receiver)
Returns an assert on the DoubleArray's size.
public static void isEqualTo(Assert<kotlin.Array[]> $receiver, double[] expected)
Asserts the DoubleArray contents are equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isNotEqualTopublic static void isNotEqualTo(Assert<kotlin.Array[]> $receiver, double[] expected)
Asserts the DoubleArray contents are not equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isEqualTopublic static void doubleArrayIsEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the DoubleArray is empty.
public static void doubleArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the DoubleArray is not empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void doubleArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the DoubleArray is null or empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void doubleArrayHasSize(Assert<kotlin.Array[]> $receiver, int size)
Asserts the DoubleArray has the expected size.
public static void doubleArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, double[] other)
Asserts the DoubleArray has the same size as the expected array.
public static void doubleArrayContains(Assert<kotlin.Array[]> $receiver, double element)
Asserts the DoubleArray contains the expected element, using in.
PrimativeArrayKt.byteArrayDoesNotContainpublic static void doubleArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, double element)
Asserts the DoubleArray does not contain the expected element, using !in.
PrimativeArrayKt.byteArrayContainspublic static void containsNone(Assert<kotlin.Array[]> $receiver, double elements)
Asserts the DoubleArray does not contain any of the expected elements.
PrimativeArrayKt.byteArrayContainsAllpublic 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.
public static void doubleArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Double>,kotlin.Unit> f)
Returns an assert that assertion on the value at the given index in the array.
assertThat(doubleArrayOf(0, 1, 2)).index(1) { it.isPositive() }
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()
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.
PrimativeArrayKt.byteArrayContainsAllpublic 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)
}
public static Assert<java.lang.Integer> charArraySize(Assert<kotlin.Array[]> $receiver)
Returns an assert on the CharArray's size.
public static void isEqualTo(Assert<kotlin.Array[]> $receiver, char[] expected)
Asserts the CharArray contents are equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isNotEqualTopublic static void isNotEqualTo(Assert<kotlin.Array[]> $receiver, char[] expected)
Asserts the CharArray contents are not equal to the expected one, using contentDeepEquals.
PrimativeArrayKt.isEqualTopublic static void charArrayIsEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the CharArray is empty.
public static void charArrayIsNotEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the CharArray is not empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void charArrayIsNullOrEmpty(Assert<kotlin.Array[]> $receiver)
Asserts the CharArray is null or empty.
PrimativeArrayKt.byteArrayIsEmptypublic static void charArrayHasSize(Assert<kotlin.Array[]> $receiver, int size)
Asserts the CharArray has the expected size.
public static void charArrayHasSameSizeAs(Assert<kotlin.Array[]> $receiver, char[] other)
Asserts the CharArray has the same size as the expected array.
public static void charArrayContains(Assert<kotlin.Array[]> $receiver, char element)
Asserts the CharArray contains the expected element, using in.
PrimativeArrayKt.byteArrayDoesNotContainpublic static void charArrayDoesNotContain(Assert<kotlin.Array[]> $receiver, char element)
Asserts the CharArray does not contain the expected element, using !in.
PrimativeArrayKt.byteArrayContainspublic static void containsNone(Assert<kotlin.Array[]> $receiver, char elements)
Asserts the CharArray does not contain any of the expected elements.
PrimativeArrayKt.byteArrayContainsAllpublic 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.
public static void charArrayIndexOld(Assert<kotlin.Array[]> $receiver, int index, kotlin.jvm.functions.Function1<? super assertk.Assert<java.lang.Character>,kotlin.Unit> f)
Returns an assert that assertion on the value at the given index in the array.
assertThat(charArrayOf(0, 1, 2)).index(1) { it.isPositive() }
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()
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.
PrimativeArrayKt.byteArrayContainsAllpublic 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)
}