com.shakelang.util.testlib/com.shakelang.util.testlib

Package-level declarations

Types

Link copied to clipboard
class CallCounter

A class to count calls

Functions

Link copied to clipboard
infix fun BooleanArray.shouldContainExactly(other: BooleanArray)

Check if the BooleanArray contains exactly the same elements as the other (Same order, same elements)

infix fun BooleanArray.shouldContainExactly(other: Collection<Boolean>)

Check if the BooleanArray contains exactly the same elements as the other (Same order, same elements)

infix fun BooleanArray.shouldContainExactly(other: Sequence<Boolean>)

Check if the BooleanArray contains exactly the same elements as the other (Same order, same elements)

infix fun ByteArray.shouldContainExactly(other: ByteArray)

Check if the ByteArray contains exactly the same elements as the other (Same order, same elements)

infix fun ByteArray.shouldContainExactly(other: Collection<Byte>)

Check if the ByteArray contains exactly the same elements as the other (Same order, same elements)

infix fun ByteArray.shouldContainExactly(other: Sequence<Byte>)

Check if the ByteArray contains exactly the same elements as the other (Same order, same elements)

infix fun CharArray.shouldContainExactly(other: CharArray)

Check if the CharArray contains exactly the same elements as the other (Same order, same elements)

infix fun CharArray.shouldContainExactly(other: Collection<Char>)

Check if the CharArray contains exactly the same elements as the other (Same order, same elements)

infix fun CharArray.shouldContainExactly(other: Sequence<Char>)

Check if the CharArray contains exactly the same elements as the other (Same order, same elements)

infix fun DoubleArray.shouldContainExactly(other: DoubleArray)

Check if the DoubleArray contains exactly the same elements as the other (Same order, same elements)

infix fun DoubleArray.shouldContainExactly(other: Collection<Double>)

Check if the DoubleArray contains exactly the same elements as the other (Same order, same elements)

infix fun DoubleArray.shouldContainExactly(other: Sequence<Double>)

Check if the DoubleArray contains exactly the same elements as the other (Same order, same elements)

infix fun FloatArray.shouldContainExactly(other: FloatArray)

Check if the FloatArray contains exactly the same elements as the other (Same order, same elements)

infix fun FloatArray.shouldContainExactly(other: Collection<Float>)

Check if the FloatArray contains exactly the same elements as the other (Same order, same elements)

infix fun FloatArray.shouldContainExactly(other: Sequence<Float>)

Check if the FloatArray contains exactly the same elements as the other (Same order, same elements)

infix fun IntArray.shouldContainExactly(other: IntArray)

Check if the IntArray contains exactly the same elements as the other (Same order, same elements)

infix fun IntArray.shouldContainExactly(other: Collection<Int>)

Check if the IntArray contains exactly the same elements as the other (Same order, same elements)

infix fun IntArray.shouldContainExactly(other: Sequence<Int>)

Check if the IntArray contains exactly the same elements as the other (Same order, same elements)

infix fun LongArray.shouldContainExactly(other: LongArray)

Check if the LongArray contains exactly the same elements as the other (Same order, same elements)

infix fun LongArray.shouldContainExactly(other: Collection<Long>)

Check if the LongArray contains exactly the same elements as the other (Same order, same elements)

infix fun LongArray.shouldContainExactly(other: Sequence<Long>)

Check if the LongArray contains exactly the same elements as the other (Same order, same elements)

infix fun ShortArray.shouldContainExactly(other: ShortArray)

Check if the ShortArray contains exactly the same elements as the other (Same order, same elements)

infix fun ShortArray.shouldContainExactly(other: Collection<Short>)

Check if the ShortArray contains exactly the same elements as the other (Same order, same elements)

infix fun ShortArray.shouldContainExactly(other: Sequence<Short>)

Check if the ShortArray contains exactly the same elements as the other (Same order, same elements)

infix fun UByteArray.shouldContainExactly(other: UByteArray)

Check if the UByteArray contains exactly the same elements as the other (Same order, same elements)

infix fun UByteArray.shouldContainExactly(other: Collection<UByte>)

Check if the UByteArray contains exactly the same elements as the other (Same order, same elements)

infix fun UByteArray.shouldContainExactly(other: Sequence<UByte>)

Check if the UByteArray contains exactly the same elements as the other (Same order, same elements)

infix fun UIntArray.shouldContainExactly(other: UIntArray)

Check if the UIntArray contains exactly the same elements as the other (Same order, same elements)

infix fun UIntArray.shouldContainExactly(other: Collection<UInt>)

Check if the UIntArray contains exactly the same elements as the other (Same order, same elements)

infix fun UIntArray.shouldContainExactly(other: Sequence<UInt>)

Check if the UIntArray contains exactly the same elements as the other (Same order, same elements)

infix fun ULongArray.shouldContainExactly(other: ULongArray)

Check if the ULongArray contains exactly the same elements as the other (Same order, same elements)

infix fun ULongArray.shouldContainExactly(other: Collection<ULong>)

Check if the ULongArray contains exactly the same elements as the other (Same order, same elements)

infix fun ULongArray.shouldContainExactly(other: Sequence<ULong>)

Check if the ULongArray contains exactly the same elements as the other (Same order, same elements)

infix fun UShortArray.shouldContainExactly(other: UShortArray)

Check if the UShortArray contains exactly the same elements as the other (Same order, same elements)

infix fun UShortArray.shouldContainExactly(other: Collection<UShort>)

Check if the UShortArray contains exactly the same elements as the other (Same order, same elements)

infix fun UShortArray.shouldContainExactly(other: Sequence<UShort>)

Check if the UShortArray contains exactly the same elements as the other (Same order, same elements)

Link copied to clipboard
infix fun BooleanArray.shouldNotContainExactly(other: BooleanArray)

Check if the BooleanArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun BooleanArray.shouldNotContainExactly(other: Collection<Boolean>)

Check if the BooleanArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun BooleanArray.shouldNotContainExactly(other: Sequence<Boolean>)

Check if the BooleanArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun ByteArray.shouldNotContainExactly(other: ByteArray)

Check if the ByteArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun ByteArray.shouldNotContainExactly(other: Collection<Byte>)

Check if the ByteArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun ByteArray.shouldNotContainExactly(other: Sequence<Byte>)

Check if the ByteArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun CharArray.shouldNotContainExactly(other: CharArray)

Check if the CharArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun CharArray.shouldNotContainExactly(other: Collection<Char>)

Check if the CharArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun CharArray.shouldNotContainExactly(other: Sequence<Char>)

Check if the CharArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun DoubleArray.shouldNotContainExactly(other: DoubleArray)

Check if the DoubleArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun DoubleArray.shouldNotContainExactly(other: Collection<Double>)

Check if the DoubleArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun DoubleArray.shouldNotContainExactly(other: Sequence<Double>)

Check if the DoubleArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun FloatArray.shouldNotContainExactly(other: FloatArray)

Check if the FloatArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun FloatArray.shouldNotContainExactly(other: Collection<Float>)

Check if the FloatArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun FloatArray.shouldNotContainExactly(other: Sequence<Float>)

Check if the FloatArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun IntArray.shouldNotContainExactly(other: IntArray)

Check if the IntArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun IntArray.shouldNotContainExactly(other: Collection<Int>)

Check if the IntArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun IntArray.shouldNotContainExactly(other: Sequence<Int>)

Check if the IntArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun LongArray.shouldNotContainExactly(other: LongArray)

Check if the LongArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun LongArray.shouldNotContainExactly(other: Collection<Long>)

Check if the LongArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun LongArray.shouldNotContainExactly(other: Sequence<Long>)

Check if the LongArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun ShortArray.shouldNotContainExactly(other: ShortArray)

Check if the ShortArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun ShortArray.shouldNotContainExactly(other: Collection<Short>)

Check if the ShortArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun ShortArray.shouldNotContainExactly(other: Sequence<Short>)

Check if the ShortArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun UByteArray.shouldNotContainExactly(other: UByteArray)

Check if the UByteArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun UByteArray.shouldNotContainExactly(other: Collection<UByte>)

Check if the UByteArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun UByteArray.shouldNotContainExactly(other: Sequence<UByte>)

Check if the UByteArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun UIntArray.shouldNotContainExactly(other: UIntArray)

Check if the UIntArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun UIntArray.shouldNotContainExactly(other: Collection<UInt>)

Check if the UIntArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun UIntArray.shouldNotContainExactly(other: Sequence<UInt>)

Check if the UIntArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun ULongArray.shouldNotContainExactly(other: ULongArray)

Check if the ULongArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun ULongArray.shouldNotContainExactly(other: Collection<ULong>)

Check if the ULongArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun ULongArray.shouldNotContainExactly(other: Sequence<ULong>)

Check if the ULongArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun UShortArray.shouldNotContainExactly(other: UShortArray)

Check if the UShortArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun UShortArray.shouldNotContainExactly(other: Collection<UShort>)

Check if the UShortArray does not contain exactly the same elements as the other (Same order, same elements)

infix fun UShortArray.shouldNotContainExactly(other: Sequence<UShort>)

Check if the UShortArray does not contain exactly the same elements as the other (Same order, same elements)