Ilya Chernikov
1346 lines
58 KiB
Kotlin
1346 lines
58 KiB
Kotlin
/*
|
|
* Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
|
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
|
*/
|
|
|
|
package test.collections
|
|
|
|
import test.assertArrayContentEquals
|
|
import test.collections.behaviors.collectionBehavior
|
|
import test.collections.behaviors.listBehavior
|
|
import test.collections.behaviors.iteratorBehavior
|
|
import kotlin.test.*
|
|
|
|
|
|
class UnsignedArraysTest {
|
|
|
|
@Test
|
|
fun collectionBehavior() {
|
|
compare(listOf<UByte>(), ubyteArrayOf()) { collectionBehavior() }
|
|
compare(listOf<UShort>(1u), ushortArrayOf(1u)) { collectionBehavior() }
|
|
compare(listOf<UInt>(1u, 2u), uintArrayOf(1u, 2u)) { collectionBehavior() }
|
|
compare(listOf<ULong>(1u, 2u, 3u), ulongArrayOf(1u, 2u, 3u)) { collectionBehavior() }
|
|
}
|
|
|
|
@Test
|
|
fun ubyteArrayInit() {
|
|
val zeroArray = UByteArray(42)
|
|
assertEquals(42, zeroArray.size)
|
|
for (index in zeroArray.indices) {
|
|
assertEquals(0u, zeroArray[index])
|
|
}
|
|
|
|
val initArray = UByteArray(42) { it.toUByte() }
|
|
for (index in initArray.indices) {
|
|
assertEquals(index.toUByte(), initArray[index])
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun ushortArrayInit() {
|
|
val zeroArray = UShortArray(42)
|
|
assertEquals(42, zeroArray.size)
|
|
for (index in zeroArray.indices) {
|
|
assertEquals(0u, zeroArray[index])
|
|
}
|
|
|
|
val initArray = UShortArray(42) { it.toUShort() }
|
|
for (index in initArray.indices) {
|
|
assertEquals(index.toUShort(), initArray[index])
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun uintArrayInit() {
|
|
val zeroArray = UIntArray(42)
|
|
assertEquals(42, zeroArray.size)
|
|
for (index in zeroArray.indices) {
|
|
assertEquals(0u, zeroArray[index])
|
|
}
|
|
|
|
val initArray = UIntArray(42) { it.toUInt() }
|
|
for (index in initArray.indices) {
|
|
assertEquals(index.toUInt(), initArray[index])
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun ulongArrayInit() {
|
|
val zeroArray = ULongArray(42)
|
|
assertEquals(42, zeroArray.size)
|
|
for (index in zeroArray.indices) {
|
|
assertEquals(0u, zeroArray[index])
|
|
}
|
|
|
|
val initArray = ULongArray(42) { it.toULong() }
|
|
for (index in initArray.indices) {
|
|
assertEquals(index.toULong(), initArray[index])
|
|
}
|
|
}
|
|
|
|
|
|
@Test
|
|
fun contentHashCode() {
|
|
ulongArrayOf(1uL, ULong.MAX_VALUE, ULong.MIN_VALUE).let { assertEquals(it.toList().hashCode(), it.contentHashCode()) }
|
|
uintArrayOf(1u, UInt.MAX_VALUE, UInt.MIN_VALUE).let { assertEquals(it.toList().hashCode(), it.contentHashCode()) }
|
|
ushortArrayOf(1u, UShort.MAX_VALUE, UShort.MIN_VALUE).let { assertEquals(it.toList().hashCode(), it.contentHashCode()) }
|
|
ubyteArrayOf(1u, UByte.MAX_VALUE, UByte.MIN_VALUE).let { assertEquals(it.toList().hashCode(), it.contentHashCode()) }
|
|
|
|
(null as ULongArray?).let { assertEquals(it?.toList().hashCode(), it.contentHashCode()) }
|
|
}
|
|
|
|
@Test
|
|
fun contentToString() {
|
|
ulongArrayOf(1uL, ULong.MAX_VALUE, ULong.MIN_VALUE).let { assertEquals(it.toList().toString(), it.contentToString()) }
|
|
uintArrayOf(1u, UInt.MAX_VALUE, UInt.MIN_VALUE).let { assertEquals(it.toList().toString(), it.contentToString()) }
|
|
ushortArrayOf(1u, UShort.MAX_VALUE, UShort.MIN_VALUE).let { assertEquals(it.toList().toString(), it.contentToString()) }
|
|
ubyteArrayOf(1u, UByte.MAX_VALUE, UByte.MIN_VALUE).let { assertEquals(it.toList().toString(), it.contentToString()) }
|
|
|
|
(null as UIntArray?).let { assertEquals(it?.toList().toString(), it.contentToString()) }
|
|
}
|
|
|
|
@Test
|
|
fun contentEquals() {
|
|
uintArrayOf(1u, UInt.MAX_VALUE, UInt.MIN_VALUE).let { arr ->
|
|
assertTrue(arr contentEquals UIntArray(arr.size, arr::get))
|
|
assertFalse(arr contentEquals UIntArray(arr.size - 1, arr::get))
|
|
}
|
|
ulongArrayOf(1u, ULong.MAX_VALUE, ULong.MIN_VALUE).let { arr ->
|
|
assertTrue(arr contentEquals ULongArray(arr.size, arr::get))
|
|
assertFalse(arr contentEquals ULongArray(arr.size - 1, arr::get))
|
|
}
|
|
ushortArrayOf(1u, UShort.MAX_VALUE, UShort.MIN_VALUE).let { arr ->
|
|
assertTrue(arr contentEquals UShortArray(arr.size, arr::get))
|
|
assertFalse(arr contentEquals UShortArray(arr.size - 1, arr::get))
|
|
}
|
|
ubyteArrayOf(1u, UByte.MAX_VALUE, UByte.MIN_VALUE).let { arr ->
|
|
assertTrue(arr contentEquals UByteArray(arr.size, arr::get))
|
|
assertFalse(arr contentEquals UByteArray(arr.size - 1, arr::get))
|
|
}
|
|
|
|
assertTrue((null as UShortArray?) contentEquals null)
|
|
assertFalse(null contentEquals ubyteArrayOf(1u))
|
|
assertFalse(ulongArrayOf() contentEquals null)
|
|
}
|
|
|
|
@Test
|
|
fun asArray() {
|
|
val uintArray = uintArrayOf(1u, UInt.MAX_VALUE)
|
|
val intArray = uintArray.asIntArray()
|
|
assertTrue(intArray contentEquals intArrayOf(1, -1))
|
|
|
|
intArray.reverse()
|
|
val uintArray2 = intArray.asUIntArray()
|
|
|
|
assertTrue(uintArray contentEquals uintArray2)
|
|
assertTrue(uintArray contentEquals uintArrayOf(UInt.MAX_VALUE, 1u))
|
|
|
|
|
|
val ulongArray = ulongArrayOf(1u, ULong.MAX_VALUE)
|
|
val longArray = ulongArray.asLongArray()
|
|
assertTrue(longArray contentEquals longArrayOf(1, -1))
|
|
|
|
longArray.reverse()
|
|
val ulongArray2 = longArray.asULongArray()
|
|
assertTrue(ulongArray contentEquals ulongArray2)
|
|
assertTrue(ulongArray contentEquals ulongArrayOf(ULong.MAX_VALUE, 1u))
|
|
}
|
|
|
|
|
|
@Test
|
|
fun toArray() {
|
|
val uintArray = uintArrayOf(UInt.MAX_VALUE)
|
|
val intArray = uintArray.toIntArray()
|
|
assertTrue(intArray contentEquals intArrayOf(-1))
|
|
|
|
intArray[0] = 0
|
|
val uintArray2 = intArray.toUIntArray()
|
|
assertEquals(UInt.MAX_VALUE, uintArray[0])
|
|
|
|
intArray[0] = 1
|
|
assertEquals(0u, uintArray2[0])
|
|
|
|
|
|
val ulongArray = ulongArrayOf(ULong.MAX_VALUE)
|
|
val longArray = ulongArray.toLongArray()
|
|
assertTrue(longArray contentEquals longArrayOf(-1))
|
|
|
|
longArray[0] = 0
|
|
val ulongArray2 = longArray.toULongArray()
|
|
assertEquals(ULong.MAX_VALUE, ulongArray[0])
|
|
|
|
longArray[0] = 1
|
|
assertEquals(0u, ulongArray2[0])
|
|
}
|
|
|
|
@Test
|
|
fun toTypedArray() {
|
|
uintArrayOf(UInt.MIN_VALUE, UInt.MAX_VALUE).let { assertTrue(it.toTypedArray() contentEquals it.toList().toTypedArray()) }
|
|
ulongArrayOf(ULong.MIN_VALUE, ULong.MAX_VALUE).let { assertTrue(it.toTypedArray() contentEquals it.toList().toTypedArray()) }
|
|
ushortArrayOf(UShort.MIN_VALUE, UShort.MAX_VALUE).let { assertTrue(it.toTypedArray() contentEquals it.toList().toTypedArray()) }
|
|
ubyteArrayOf(UByte.MIN_VALUE, UByte.MAX_VALUE).let { assertTrue(it.toTypedArray() contentEquals it.toList().toTypedArray()) }
|
|
}
|
|
|
|
@Test
|
|
fun copyOf() {
|
|
uintArrayOf(UInt.MAX_VALUE).let { arr ->
|
|
val copy = arr.copyOf()
|
|
assertTrue(arr contentEquals copy)
|
|
copy[0] = 1u
|
|
assertFalse(arr contentEquals copy)
|
|
arr[0] = 2u
|
|
assertFalse(arr contentEquals copy)
|
|
}
|
|
ulongArrayOf(ULong.MAX_VALUE).let { arr ->
|
|
val copy = arr.copyOf()
|
|
assertTrue(arr contentEquals copy)
|
|
copy[0] = 1u
|
|
assertFalse(arr contentEquals copy)
|
|
arr[0] = 2u
|
|
assertFalse(arr contentEquals copy)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyAndResize() {
|
|
assertTrue(uintArrayOf(1u, 2u) contentEquals uintArrayOf(1u, 2u, 3u).copyOf(2))
|
|
assertTrue(uintArrayOf(1u, 2u, 0u) contentEquals uintArrayOf(1u, 2u).copyOf(3))
|
|
|
|
assertTrue(ulongArrayOf(1u, 2u) contentEquals ulongArrayOf(1u, 2u, 3u).copyOf(2))
|
|
assertTrue(ulongArrayOf(1u, 2u, 0u) contentEquals ulongArrayOf(1u, 2u).copyOf(3))
|
|
|
|
|
|
assertTrue(uintArrayOf() contentEquals uintArrayOf(1u).copyOf(0))
|
|
assertTrue(ulongArrayOf() contentEquals ulongArrayOf(1u).copyOf(0))
|
|
|
|
// RuntimeException is the most specific common of JVM and JS implementations
|
|
assertFailsWith<RuntimeException> { uintArrayOf().copyOf(-1) }
|
|
assertFailsWith<RuntimeException> { ulongArrayOf().copyOf(-1) }
|
|
}
|
|
|
|
|
|
@Test
|
|
fun copyOfRange() {
|
|
assertTrue(ubyteArrayOf(0u, 1u, 2u) contentEquals ubyteArrayOf(0u, 1u, 2u, 3u, 4u, 5u).copyOfRange(0, 3))
|
|
assertTrue(ushortArrayOf(0u, 1u, 2u) contentEquals ushortArrayOf(0u, 1u, 2u, 3u, 4u, 5u).copyOfRange(0, 3))
|
|
assertTrue(uintArrayOf(0u, 1u, 2u) contentEquals uintArrayOf(0u, 1u, 2u, 3u, 4u, 5u).copyOfRange(0, 3))
|
|
assertTrue(ulongArrayOf(0u, 1u, 2u) contentEquals ulongArrayOf(0u, 1u, 2u, 3u, 4u, 5u).copyOfRange(0, 3))
|
|
|
|
for (pos in 0..3) {
|
|
assertTrue(uintArrayOf() contentEquals uintArrayOf(1u, 2u, 3u).copyOfRange(pos, pos))
|
|
assertTrue(ulongArrayOf() contentEquals ULongArray(3) { it.toULong() }.copyOfRange(pos, pos))
|
|
}
|
|
|
|
for ((start, end) in listOf(-1 to 0, 0 to 2, 2 to 2, 1 to 0)) {
|
|
val bounds = "start: $start, end: $end"
|
|
val exClass = if (start > end) IllegalArgumentException::class else IndexOutOfBoundsException::class
|
|
assertFailsWith(exClass, bounds) { uintArrayOf(1u).copyOfRange(start, end) }
|
|
assertFailsWith(exClass, bounds) { ulongArrayOf(1uL).copyOfRange(start, end) }
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun plus() {
|
|
assertArrayContentEquals(uintArrayOf(1u, 2u, 3u), uintArrayOf(1u, 2u) + 3u)
|
|
assertArrayContentEquals(uintArrayOf(1u, 2u, 3u, 4u), uintArrayOf(1u, 2u) + listOf(3u, 4u))
|
|
assertArrayContentEquals(uintArrayOf(1u, 2u, 3u, 4u), uintArrayOf(1u, 2u) + uintArrayOf(3u, 4u))
|
|
}
|
|
|
|
@Test
|
|
fun indexOf() {
|
|
expect(-1) { ubyteArrayOf(1u, 2u, 3u).indexOf(0u) }
|
|
expect(0) { ushortArrayOf(1u, 2u, 3u).indexOf(1u) }
|
|
expect(1) { uintArrayOf(1u, 2u, 3u).indexOf(2u) }
|
|
expect(2) { ulongArrayOf(1u, 2u, 3u).indexOf(3u) }
|
|
}
|
|
|
|
@Test
|
|
fun indexOfFirst() {
|
|
expect(-1) { ubyteArrayOf(1u, 2u, 3u).indexOfFirst { it == 5.toUByte() } }
|
|
expect(0) { ushortArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 1u } }
|
|
expect(1) { uintArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 0u } }
|
|
expect(2) { ulongArrayOf(1u, 2u, 3u).indexOfFirst { it == 3.toULong() } }
|
|
}
|
|
|
|
@Test
|
|
fun lastIndexOf() {
|
|
expect(-1) { ubyteArrayOf(1u, 2u, 3u).lastIndexOf(0u) }
|
|
expect(0) { ushortArrayOf(1u, 2u, 3u).lastIndexOf(1u) }
|
|
expect(1) { uintArrayOf(2u, 2u, 3u).lastIndexOf(2u) }
|
|
expect(2) { ulongArrayOf(3u, 2u, 3u).lastIndexOf(3u) }
|
|
}
|
|
|
|
@Test
|
|
fun indexOfLast() {
|
|
expect(-1) { ubyteArrayOf(1u, 2u, 3u).indexOfLast { it == 5.toUByte() } }
|
|
expect(2) { ushortArrayOf(1u, 2u, 3u).indexOfLast { it % 2u == 1u } }
|
|
expect(1) { uintArrayOf(1u, 2u, 3u).indexOfLast { it % 2u == 0u } }
|
|
expect(0) { ulongArrayOf(1u, 2u, 3u).indexOfLast { it == 1.toULong() } }
|
|
}
|
|
|
|
@Test
|
|
fun indices() {
|
|
expect(0 until 0) { ubyteArrayOf().indices }
|
|
expect(0 until 1) { ushortArrayOf(1u).indices }
|
|
expect(0 until 2) { uintArrayOf(1u, 2u).indices }
|
|
expect(0 until 3) { ulongArrayOf(1u, 2u, 3u).indices }
|
|
}
|
|
|
|
@Test
|
|
fun lastIndex() {
|
|
expect(-1) { ubyteArrayOf().lastIndex }
|
|
expect(0) { ushortArrayOf(1u).lastIndex }
|
|
expect(1) { uintArrayOf(1u, 2u).lastIndex }
|
|
expect(2) { ulongArrayOf(1u, 2u, 3u).lastIndex }
|
|
}
|
|
|
|
@Test
|
|
fun all() {
|
|
assertTrue(ubyteArrayOf(0u, 1u, 2u).all { it < 3u })
|
|
assertFalse(ushortArrayOf(0u, 1u, 2u).all { it % 2u == 0u })
|
|
assertTrue(uintArrayOf(0u, 2u, 4u).all { it % 2u == 0u })
|
|
assertTrue(ulongArrayOf(2u, 3u, 4u).all { it > 1uL })
|
|
}
|
|
|
|
@Test
|
|
fun none() {
|
|
assertTrue(ubyteArrayOf(0u, 1u, 2u).none { it > 2u })
|
|
assertFalse(ushortArrayOf(0u, 1u, 2u).none { it % 2u == 0u })
|
|
assertTrue(uintArrayOf(0u, 2u, 4u).none { it % 2u != 0u })
|
|
assertTrue(ulongArrayOf(2u, 3u, 4u).none { it < 2uL })
|
|
}
|
|
|
|
@Test
|
|
fun any() {
|
|
assertTrue(ubyteArrayOf(0u, 1u, 2u).any { it >= 2u })
|
|
assertFalse(ushortArrayOf(0u, 1u, 2u).any { it == 5.toUShort() })
|
|
assertTrue(uintArrayOf(0u, 2u, 4u).any { it % 3u == 1u })
|
|
assertTrue(ulongArrayOf(2u, 3u, 4u).any { it % 3uL == 0uL })
|
|
}
|
|
|
|
@Test
|
|
fun count() {
|
|
assertEquals(1, ubyteArrayOf(0u, 1u, 2u).count { it >= 2u })
|
|
assertEquals(2, ushortArrayOf(0u, 1u, 2u).count { it % 2u == 0u })
|
|
assertEquals(0, uintArrayOf(0u, 2u, 4u).count { it % 2u != 0u })
|
|
assertEquals(3, ulongArrayOf(2u, 3u, 4u).count { it > 1uL })
|
|
}
|
|
|
|
@Suppress("DEPRECATION")
|
|
@Test
|
|
fun sumBy() {
|
|
assertEquals(3u, ubyteArrayOf(0u, 1u, 2u).sumBy { it.toUInt() })
|
|
assertEquals(1u, ushortArrayOf(0u, 1u, 2u).sumBy { it % 2u })
|
|
assertEquals(0u, uintArrayOf(0u, 2u, 4u).sumBy { it % 2u })
|
|
assertEquals(6u, ulongArrayOf(2u, 3u, 4u).sumBy { (it - 1u).toUInt() })
|
|
}
|
|
|
|
@Suppress("DEPRECATION")
|
|
@Test
|
|
fun sumByDouble() {
|
|
assertEquals(3.0, ubyteArrayOf(0u, 1u, 2u).sumByDouble { it.toDouble() })
|
|
assertEquals(1.0, ushortArrayOf(0u, 1u, 2u).sumByDouble { (it % 2u).toDouble() })
|
|
assertEquals(0.0, uintArrayOf(0u, 2u, 4u).sumByDouble { (it % 2u).toDouble() })
|
|
assertEquals(6.0, ulongArrayOf(2u, 3u, 4u).sumByDouble { (it - 1u).toDouble() })
|
|
}
|
|
|
|
@Test
|
|
fun toUnsignedArray() {
|
|
val uintList = listOf(1u, 2u, 3u)
|
|
val uintArray: UIntArray = uintList.toUIntArray()
|
|
expect(3) { uintArray.size }
|
|
assertEquals(uintList, uintArray.toList())
|
|
|
|
val genericArray: Array<ULong> = arrayOf<ULong>(1u, 2u, 3u)
|
|
val ulongArray: ULongArray = genericArray.toULongArray()
|
|
expect(3) { ulongArray.size }
|
|
assertEquals(genericArray.toList(), ulongArray.toList())
|
|
}
|
|
|
|
@Test
|
|
fun reversed() {
|
|
expect(listOf(3u, 2u, 1u)) { uintArrayOf(1u, 2u, 3u).reversed() }
|
|
expect(listOf<UByte>(3u, 2u, 1u)) { ubyteArrayOf(1u, 2u, 3u).reversed() }
|
|
expect(listOf<UShort>(3u, 2u, 1u)) { ushortArrayOf(1u, 2u, 3u).reversed() }
|
|
expect(listOf<ULong>(3u, 2u, 1u)) { ulongArrayOf(1u, 2u, 3u).reversed() }
|
|
}
|
|
|
|
@Test
|
|
fun reversedArray() {
|
|
assertArrayContentEquals(uintArrayOf(3u, 2u, 1u), uintArrayOf(1u, 2u, 3u).reversedArray())
|
|
assertArrayContentEquals(ubyteArrayOf(3u, 2u, 1u), ubyteArrayOf(1u, 2u, 3u).reversedArray())
|
|
assertArrayContentEquals(ushortArrayOf(3u, 2u, 1u), ushortArrayOf(1u, 2u, 3u).reversedArray())
|
|
assertArrayContentEquals(ulongArrayOf(3u, 2u, 1u), ulongArrayOf(1u, 2u, 3u).reversedArray())
|
|
}
|
|
|
|
@Test
|
|
fun asList() {
|
|
compare(listOf<UByte>(), ubyteArrayOf().asList()) { listBehavior() }
|
|
compare(listOf<UShort>(1u), ushortArrayOf(1.toUShort()).asList()) { listBehavior() }
|
|
compare(listOf<UInt>(1u, 2u), uintArrayOf(1u, 2u).asList()) { listBehavior() }
|
|
compare(listOf<UInt>(1u, 2u, 3u), uintArrayOf(1u, 2u, 3u).asList()) { listBehavior() }
|
|
|
|
val ulongs = ulongArrayOf(1uL, 5uL, 7uL)
|
|
val ulongsAsList = ulongs.asList()
|
|
assertEquals(5uL, ulongsAsList[1])
|
|
ulongs[1] = 10u
|
|
assertEquals(10uL, ulongsAsList[1], "Should reflect changes in original array")
|
|
}
|
|
|
|
@Test
|
|
fun slice() {
|
|
assertEquals(listOf<UInt>(), uintArrayOf(1u, 2u, 3u).slice(5..1))
|
|
assertEquals(listOf<UInt>(2u, 3u, 9u), uintArrayOf(2u, 3u, 9u, 2u, 3u, 9u).slice(listOf(3, 1, 2)))
|
|
assertEquals(listOf<UByte>(127u, 100u), ubyteArrayOf(50u, 100u, 127u).slice(2 downTo 1))
|
|
assertEquals(listOf<UShort>(200u, 100u), ushortArrayOf(50u, 100u, 200u).slice(2 downTo 1))
|
|
assertEquals(listOf<ULong>(100u, 200u, 30u), ulongArrayOf(50u, 100u, 200u, 30u).slice(1..3))
|
|
|
|
for (range in listOf(-1 until 0, 0 until 2, 2..2)) {
|
|
val bounds = "range: $range"
|
|
val exClass = IndexOutOfBoundsException::class
|
|
assertFailsWith(exClass, bounds) { uintArrayOf(1u).slice(range) }
|
|
assertFailsWith(exClass, bounds) { ulongArrayOf(1u).slice(range) }
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun sliceArray() {
|
|
assertArrayContentEquals(uintArrayOf(), uintArrayOf(1u, 2u, 3u).sliceArray(5..1))
|
|
assertArrayContentEquals(uintArrayOf(2u, 3u, 9u), uintArrayOf(2u, 3u, 9u, 2u, 3u, 9u).sliceArray(listOf(3, 1, 2)))
|
|
assertArrayContentEquals(ubyteArrayOf(127u, 100u), ubyteArrayOf(50u, 100u, 127u).sliceArray(listOf(2, 1)))
|
|
assertArrayContentEquals(ushortArrayOf(200u, 100u), ushortArrayOf(50u, 100u, 200u).sliceArray(listOf(2, 1)))
|
|
assertArrayContentEquals(ulongArrayOf(100u, 200u, 30u), ulongArrayOf(50u, 100u, 200u, 30u).sliceArray(1..3))
|
|
|
|
for (range in listOf(-1 until 0, 0 until 2, 2..2)) {
|
|
val bounds = "range: $range"
|
|
val exClass = IndexOutOfBoundsException::class
|
|
assertFailsWith(exClass, bounds) { ubyteArrayOf(1u).sliceArray(range) }
|
|
assertFailsWith(exClass, bounds) { ushortArrayOf(1u).sliceArray(range) }
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun minOrNull() {
|
|
expect(null) { arrayOf<UByte>().minOrNull() }
|
|
expect(1u) { arrayOf<UShort>(1u).minOrNull() }
|
|
expect(2u) { arrayOf<UInt>(2u, 3u).minOrNull() }
|
|
expect(2uL) { arrayOf<ULong>(3u, 2u).minOrNull() }
|
|
}
|
|
|
|
@Test
|
|
fun minOrNullInUnsignedArrays() {
|
|
expect(null) { ubyteArrayOf().minOrNull() }
|
|
expect(1u) { ushortArrayOf(1u).minOrNull() }
|
|
expect(2u) { uintArrayOf(2u, 3u).minOrNull() }
|
|
expect(2uL) { ulongArrayOf(3u, 2u).minOrNull() }
|
|
}
|
|
|
|
@Test
|
|
fun maxOrNull() {
|
|
expect(null) { arrayOf<UByte>().maxOrNull() }
|
|
expect(1u) { arrayOf<UShort>(1u).maxOrNull() }
|
|
expect(3u) { arrayOf<UInt>(2u, 3u).maxOrNull() }
|
|
expect(3uL) { arrayOf<ULong>(3u, 2u).maxOrNull() }
|
|
}
|
|
|
|
@Test
|
|
fun maxOrNullInUnsignedArrays() {
|
|
expect(null) { ubyteArrayOf().maxOrNull() }
|
|
expect(1u) { ushortArrayOf(1u).maxOrNull() }
|
|
expect(3u) { uintArrayOf(2u, 3u).maxOrNull() }
|
|
expect(3uL) { ulongArrayOf(3u, 2u).maxOrNull() }
|
|
}
|
|
|
|
@Test
|
|
fun minWitOrNullh() {
|
|
expect(null) { arrayOf<UByte>().minWithOrNull(naturalOrder()) }
|
|
expect(1u) { arrayOf<UShort>(1u).minWithOrNull(naturalOrder()) }
|
|
expect(2u) { arrayOf<UInt>(2u, 3u).minWithOrNull(naturalOrder()) }
|
|
expect(2uL) { arrayOf<ULong>(3u, 2u).minWithOrNull(naturalOrder()) }
|
|
}
|
|
|
|
@Test
|
|
fun minWithOrNullInUnsignedArrays() {
|
|
expect(null) { ubyteArrayOf().minWithOrNull(reverseOrder()) }
|
|
expect(1u) { ushortArrayOf(1u).minWithOrNull(reverseOrder()) }
|
|
expect(3u) { uintArrayOf(2u, 3u).minWithOrNull(reverseOrder()) }
|
|
expect(3uL) { ulongArrayOf(3u, 2u).minWithOrNull(reverseOrder()) }
|
|
}
|
|
|
|
@Test
|
|
fun maxWithOrNull() {
|
|
expect(null) { arrayOf<UByte>().maxWithOrNull(naturalOrder()) }
|
|
expect(1u) { arrayOf<UShort>(1u).maxWithOrNull(naturalOrder()) }
|
|
expect(3u) { arrayOf<UInt>(2u, 3u).maxWithOrNull(naturalOrder()) }
|
|
expect(3uL) { arrayOf<ULong>(3u, 2u).maxWithOrNull(naturalOrder()) }
|
|
}
|
|
|
|
@Test
|
|
fun maxWithOrNullInUnsignedArrays() {
|
|
expect(null) { ubyteArrayOf().maxWithOrNull(reverseOrder()) }
|
|
expect(1u) { ushortArrayOf(1u).maxWithOrNull(reverseOrder()) }
|
|
expect(2u) { uintArrayOf(2u, 3u).maxWithOrNull(reverseOrder()) }
|
|
expect(2uL) { ulongArrayOf(3u, 2u).maxWithOrNull(reverseOrder()) }
|
|
}
|
|
|
|
@Test
|
|
fun minByOrNull() {
|
|
expect(null) { arrayOf<UByte>().minByOrNull { it * it } }
|
|
expect(1u) { arrayOf<UShort>(1u).minByOrNull { it * it } }
|
|
expect(2u) { arrayOf<UInt>(2u, 3u).minByOrNull { it * it } }
|
|
expect(3uL) { arrayOf<ULong>(3u, 2u).minByOrNull { it - 3u } }
|
|
}
|
|
|
|
@Test
|
|
fun minByOrNullInUnsignedArrays() {
|
|
expect(null) { ubyteArrayOf().minByOrNull { it * it } }
|
|
expect(1u) { ushortArrayOf(1u).minByOrNull { it * it } }
|
|
expect(2u) { uintArrayOf(2u, 3u).minByOrNull { it * it } }
|
|
expect(3uL) { ulongArrayOf(3u, 2u).minByOrNull { it - 3u } }
|
|
}
|
|
|
|
@Test
|
|
fun maxByOrNull() {
|
|
expect(null) { arrayOf<UByte>().maxByOrNull { it + 1u } }
|
|
expect(1u) { arrayOf<UShort>(1u).maxByOrNull { it + 1u } }
|
|
expect(2u) { arrayOf<UInt>(2u, 3u).maxByOrNull { it - 3u } }
|
|
expect(3uL) { arrayOf<ULong>(3u, 2u).maxByOrNull { it + 1u } }
|
|
}
|
|
|
|
@Test
|
|
fun maxByOrNullInUnsignedArrays() {
|
|
expect(null) { ubyteArrayOf().maxByOrNull { it + 1u } }
|
|
expect(1u) { ushortArrayOf(1u).maxByOrNull { it + 1u } }
|
|
expect(2u) { uintArrayOf(2u, 3u).maxByOrNull { it - 3u } }
|
|
expect(3uL) { ulongArrayOf(3u, 2u).maxByOrNull { it + 1u } }
|
|
}
|
|
|
|
@Test
|
|
fun reduce() {
|
|
expect(0u) { ubyteArrayOf(3u, 2u, 1u).reduce { acc, e -> (acc - e).toUByte() } }
|
|
expect(0u) { ushortArrayOf(3u, 2u, 1u).reduce { acc, e -> (acc - e).toUShort() } }
|
|
expect((-4).toUInt()) { uintArrayOf(1u, 2u, 3u).reduce { acc, e -> acc - e } }
|
|
expect((-4).toULong()) { ulongArrayOf(1u, 2u, 3u).reduce { acc, e -> acc - e } }
|
|
|
|
assertFailsWith<UnsupportedOperationException> {
|
|
uintArrayOf().reduce { acc, e -> acc + e }
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun reduceOrNull() {
|
|
expect(0u) { ubyteArrayOf(3u, 2u, 1u).reduceOrNull { acc, e -> (acc - e).toUByte() } }
|
|
expect(0u) { ushortArrayOf(3u, 2u, 1u).reduceOrNull { acc, e -> (acc - e).toUShort() } }
|
|
expect((-4).toUInt()) { uintArrayOf(1u, 2u, 3u).reduceOrNull { acc, e -> acc - e } }
|
|
expect((-4).toULong()) { ulongArrayOf(1u, 2u, 3u).reduceOrNull { acc, e -> acc - e } }
|
|
|
|
assertNull(uintArrayOf().reduceOrNull { acc, e -> acc + e })
|
|
}
|
|
|
|
@Test
|
|
fun reduceIndexed() {
|
|
expect(1u) { ubyteArrayOf(3u, 2u, 1u).reduceIndexed { index, acc, e -> if (index != 2) (e - acc).toUByte() else e } }
|
|
expect(1u) { ushortArrayOf(3u, 2u, 1u).reduceIndexed { index, acc, e -> if (index != 2) (e - acc).toUShort() else e } }
|
|
expect(UInt.MAX_VALUE) { uintArrayOf(1u, 2u, 3u).reduceIndexed { index, acc, e -> index.toUInt() + acc - e } }
|
|
expect(ULong.MAX_VALUE) { ulongArrayOf(1u, 2u, 3u).reduceIndexed { index, acc, e -> index.toULong() + acc - e } }
|
|
|
|
assertFailsWith<UnsupportedOperationException> {
|
|
uintArrayOf().reduceIndexed { index, acc, e -> index.toUInt() + e + acc }
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun reduceIndexedOrNull() {
|
|
expect(1u) { ubyteArrayOf(3u, 2u, 1u).reduceIndexedOrNull { index, acc, e -> if (index != 2) (e - acc).toUByte() else e } }
|
|
expect(1u) { ushortArrayOf(3u, 2u, 1u).reduceIndexedOrNull { index, acc, e -> if (index != 2) (e - acc).toUShort() else e } }
|
|
expect(UInt.MAX_VALUE) { uintArrayOf(1u, 2u, 3u).reduceIndexedOrNull { index, acc, e -> index.toUInt() + acc - e } }
|
|
expect(ULong.MAX_VALUE) { ulongArrayOf(1u, 2u, 3u).reduceIndexedOrNull { index, acc, e -> index.toULong() + acc - e } }
|
|
|
|
expect(null, { uintArrayOf().reduceIndexedOrNull { index, acc, e -> index.toUInt() + e + acc } })
|
|
}
|
|
|
|
@Test
|
|
fun reduceRight() {
|
|
expect(2u) { ubyteArrayOf(1u, 2u, 3u).reduceRightOrNull { e, acc -> (e - acc).toUByte() } }
|
|
expect(2u) { ushortArrayOf(1u, 2u, 3u).reduceRightOrNull { e, acc -> (e - acc).toUShort() } }
|
|
expect(2u) { uintArrayOf(1u, 2u, 3u).reduceRightOrNull { e, acc -> e - acc } }
|
|
expect(2uL) { ulongArrayOf(1u, 2u, 3u).reduceRightOrNull { e, acc -> e - acc } }
|
|
|
|
assertNull(uintArrayOf().reduceRightOrNull { e, acc -> e + acc })
|
|
}
|
|
|
|
@Test
|
|
fun reduceRightOrNull() {
|
|
expect(2u) { ubyteArrayOf(1u, 2u, 3u).reduceRight { e, acc -> (e - acc).toUByte() } }
|
|
expect(2u) { ushortArrayOf(1u, 2u, 3u).reduceRight { e, acc -> (e - acc).toUShort() } }
|
|
expect(2u) { uintArrayOf(1u, 2u, 3u).reduceRight { e, acc -> e - acc } }
|
|
expect(2uL) { ulongArrayOf(1u, 2u, 3u).reduceRight { e, acc -> e - acc } }
|
|
|
|
assertFailsWith<UnsupportedOperationException> {
|
|
uintArrayOf().reduceRight { e, acc -> e + acc }
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun reduceRightIndexed() {
|
|
expect(1u) { ubyteArrayOf(3u, 2u, 1u).reduceRightIndexed { index, e, acc -> if (index != 1) (e - acc).toUByte() else e } }
|
|
expect(1u) { ushortArrayOf(3u, 2u, 1u).reduceRightIndexed { index, e, acc -> if (index != 1) (e - acc).toUShort() else e } }
|
|
expect(1u) { uintArrayOf(1u, 2u, 3u).reduceRightIndexed { index, e, acc -> index.toUInt() + e - acc } }
|
|
expect(1uL) { ulongArrayOf(1u, 2u, 3u).reduceRightIndexed { index, e, acc -> index.toULong() + e - acc } }
|
|
|
|
assertFailsWith<UnsupportedOperationException> {
|
|
uintArrayOf().reduceRightIndexed { index, e, acc -> index.toUInt() + e + acc }
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun reduceRightIndexedOrNull() {
|
|
expect(1u) { ubyteArrayOf(3u, 2u, 1u).reduceRightIndexedOrNull { index, e, acc -> if (index != 1) (e - acc).toUByte() else e } }
|
|
expect(1u) { ushortArrayOf(3u, 2u, 1u).reduceRightIndexedOrNull { index, e, acc -> if (index != 1) (e - acc).toUShort() else e } }
|
|
expect(1u) { uintArrayOf(1u, 2u, 3u).reduceRightIndexedOrNull { index, e, acc -> index.toUInt() + e - acc } }
|
|
expect(1uL) { ulongArrayOf(1u, 2u, 3u).reduceRightIndexedOrNull { index, e, acc -> index.toULong() + e - acc } }
|
|
|
|
expect(null, { uintArrayOf().reduceRightIndexedOrNull { index, e, acc -> index.toUInt() + e + acc } })
|
|
}
|
|
|
|
@Test
|
|
fun forEach() {
|
|
var i = 0
|
|
val a = ubyteArrayOf(3u, 2u, 1u)
|
|
a.forEach { e -> assertEquals(e, a[i++]) }
|
|
}
|
|
|
|
@Test
|
|
fun forEachIndexed() {
|
|
val a = ubyteArrayOf(3u, 2u, 1u)
|
|
a.forEachIndexed { index, e -> assertEquals(e, a[index]) }
|
|
}
|
|
|
|
@Test
|
|
fun sum() {
|
|
expect(14u) { arrayOf(2u, 3u, 9u).asSequence().sum() }
|
|
expect(400u) { arrayOf<UByte>(200u, 200u).asList().sum() }
|
|
expect(50000u) { arrayOf<UShort>(20000u, 30000u).asIterable().sum() }
|
|
expect(12_000_000_000_000_000_000uL) { arrayOf(10_000_000_000_000_000_000uL, 2_000_000_000_000_000_000uL).sum() }
|
|
}
|
|
|
|
@Test
|
|
fun sumInUnsignedArrays() {
|
|
expect(14u) { uintArrayOf(2u, 3u, 9u).sum() }
|
|
expect(400u) { ubyteArrayOf(200u, 200u).sum() }
|
|
expect(50000u) { ushortArrayOf(20000u, 30000u).sum() }
|
|
expect(12_000_000_000_000_000_000uL) { ulongArrayOf(10_000_000_000_000_000_000uL, 2_000_000_000_000_000_000uL).sum() }
|
|
}
|
|
|
|
@Test
|
|
fun fold() {
|
|
expect(6u) { ubyteArrayOf(1u, 2u, 3u).fold(0u) { acc, e -> acc + e } }
|
|
expect(13u) { ushortArrayOf(1u, 2u, 3u).fold(1u) { acc, e -> acc + 2u * e } }
|
|
expect(6u) { uintArrayOf(1u, 2u, 3u).fold(1u) { acc, e -> acc * e } }
|
|
expect("0123") { ulongArrayOf(1u, 2u, 3u).fold("0") { acc, e -> "$acc$e" } }
|
|
}
|
|
|
|
@Test
|
|
fun foldIndexed() {
|
|
expect(8u) { ubyteArrayOf(1u, 2u, 3u).foldIndexed(0u) { i, acc, e -> acc + i.toUByte() * e } }
|
|
expect(10) { ushortArrayOf(1u, 2u, 3u).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } }
|
|
expect(15u) { uintArrayOf(1u, 2u, 3u).foldIndexed(1u) { i, acc, e -> acc * (i.toUInt() + e) } }
|
|
expect(" 0-1 1-2 2-3") { ulongArrayOf(1u, 2u, 3u).foldIndexed("") { i, acc, e -> "$acc $i-$e" } }
|
|
}
|
|
|
|
@Test
|
|
fun foldRight() {
|
|
expect(6u) { ubyteArrayOf(1u, 2u, 3u).foldRight(0u) { e, acc -> acc + e } }
|
|
expect(13u) { ushortArrayOf(1u, 2u, 3u).foldRight(1u) { e, acc -> acc + 2u * e } }
|
|
expect(6u) { uintArrayOf(1u, 2u, 3u).foldRight(1u) { e, acc -> acc * e } }
|
|
expect("0321") { ulongArrayOf(1u, 2u, 3u).foldRight("0") { e, acc -> "$acc$e" } }
|
|
}
|
|
|
|
@Test
|
|
fun foldRightIndexed() {
|
|
expect(8u) { ubyteArrayOf(1u, 2u, 3u).foldRightIndexed(0u) { i, e, acc -> acc + i.toUByte() * e } }
|
|
expect(10) { ushortArrayOf(1u, 2u, 3u).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } }
|
|
expect(15u) { uintArrayOf(1u, 2u, 3u).foldRightIndexed(1u) { i, e, acc -> acc * (i.toUInt() + e) } }
|
|
expect(" 2-3 1-2 0-1") { ulongArrayOf(1u, 2u, 3u).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } }
|
|
}
|
|
|
|
@Test
|
|
fun scan() {
|
|
for (size in 0 until 4) {
|
|
val expected = listOf("", "0", "01", "012", "0123").subList(0, size + 1)
|
|
assertEquals(expected, UByteArray(size) { it.toUByte() }.scan("") { acc, e -> acc + e })
|
|
assertEquals(expected, UShortArray(size) { it.toUShort() }.scan("") { acc, e -> acc + e })
|
|
assertEquals(expected, UIntArray(size) { it.toUInt() }.scan("") { acc, e -> acc + e })
|
|
assertEquals(expected, ULongArray(size) { it.toULong() }.scan("") { acc, e -> acc + e })
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun runningFold() {
|
|
for (size in 0 until 4) {
|
|
val expected = listOf("", "0", "01", "012", "0123").subList(0, size + 1)
|
|
assertEquals(expected, UByteArray(size) { it.toUByte() }.runningFold("") { acc, e -> acc + e })
|
|
assertEquals(expected, UShortArray(size) { it.toUShort() }.runningFold("") { acc, e -> acc + e })
|
|
assertEquals(expected, UIntArray(size) { it.toUInt() }.runningFold("") { acc, e -> acc + e })
|
|
assertEquals(expected, ULongArray(size) { it.toULong() }.runningFold("") { acc, e -> acc + e })
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun scanIndexed() {
|
|
for (size in 0 until 4) {
|
|
val expected = listOf("+", "+[0: a]", "+[0: a][1: b]", "+[0: a][1: b][2: c]", "+[0: a][1: b][2: c][3: d]").subList(0, size + 1)
|
|
assertEquals(
|
|
expected,
|
|
UByteArray(size) { it.toUByte() }.scanIndexed("+") { index, acc, e -> "$acc[$index: ${'a' + e.toInt()}]" }
|
|
)
|
|
assertEquals(
|
|
expected,
|
|
UShortArray(size) { it.toUShort() }.scanIndexed("+") { index, acc, e -> "$acc[$index: ${'a' + e.toInt()}]" }
|
|
)
|
|
assertEquals(
|
|
expected,
|
|
UIntArray(size) { it.toUInt() }.scanIndexed("+") { index, acc, e -> "$acc[$index: ${'a' + e.toInt()}]" }
|
|
)
|
|
assertEquals(
|
|
expected,
|
|
ULongArray(size) { it.toULong() }.scanIndexed("+") { index, acc, e -> "$acc[$index: ${'a' + e.toInt()}]" }
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun runningFoldIndexed() {
|
|
for (size in 0 until 4) {
|
|
val expected = listOf("+", "+[0: a]", "+[0: a][1: b]", "+[0: a][1: b][2: c]", "+[0: a][1: b][2: c][3: d]").subList(0, size + 1)
|
|
assertEquals(
|
|
expected,
|
|
UByteArray(size) { it.toUByte() }.runningFoldIndexed("+") { index, acc, e -> "$acc[$index: ${'a' + e.toInt()}]" }
|
|
)
|
|
assertEquals(
|
|
expected,
|
|
UShortArray(size) { it.toUShort() }.runningFoldIndexed("+") { index, acc, e -> "$acc[$index: ${'a' + e.toInt()}]" }
|
|
)
|
|
assertEquals(
|
|
expected,
|
|
UIntArray(size) { it.toUInt() }.runningFoldIndexed("+") { index, acc, e -> "$acc[$index: ${'a' + e.toInt()}]" }
|
|
)
|
|
assertEquals(
|
|
expected,
|
|
ULongArray(size) { it.toULong() }.runningFoldIndexed("+") { index, acc, e -> "$acc[$index: ${'a' + e.toInt()}]" }
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun runningReduce() {
|
|
for (size in 0 until 4) {
|
|
val expected = listOf(0, 1, 3, 6).subList(0, size)
|
|
assertEquals(
|
|
expected.map { it.toUByte() },
|
|
UByteArray(size) { it.toUByte() }.runningReduce { acc, e -> (acc + e).toUByte() }
|
|
)
|
|
assertEquals(
|
|
expected.map { it.toUShort() },
|
|
UShortArray(size) { it.toUShort() }.runningReduce { acc, e -> (acc + e).toUShort() }
|
|
)
|
|
assertEquals(
|
|
expected.map { it.toUInt() },
|
|
UIntArray(size) { it.toUInt() }.runningReduce { acc, e -> acc + e }
|
|
)
|
|
assertEquals(
|
|
expected.map { it.toULong() },
|
|
ULongArray(size) { it.toULong() }.runningReduce { acc, e -> acc + e }
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun runningReduceIndexed() {
|
|
for (size in 0 until 4) {
|
|
val expected = listOf(0, 1, 6, 27).subList(0, size)
|
|
assertEquals(
|
|
expected.map { it.toUByte() },
|
|
UByteArray(size) { it.toUByte() }.runningReduceIndexed { index, acc, e -> (index.toUInt() * (acc + e)).toUByte() }
|
|
)
|
|
assertEquals(
|
|
expected.map { it.toUShort() },
|
|
UShortArray(size) { it.toUShort() }.runningReduceIndexed { index, acc, e -> (index.toUInt() * (acc + e)).toUShort() }
|
|
)
|
|
assertEquals(
|
|
expected.map { it.toUInt() },
|
|
UIntArray(size) { it.toUInt() }.runningReduceIndexed { index, acc, e -> index.toUInt() * (acc + e) }
|
|
)
|
|
assertEquals(
|
|
expected.map { it.toULong() },
|
|
ULongArray(size) { it.toULong() }.runningReduceIndexed { index, acc, e -> index.toULong() * (acc + e) }
|
|
)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun associateWithPrimitives() {
|
|
assertEquals(
|
|
mapOf(1u to "1", 2u to "2", 3u to "3"),
|
|
uintArrayOf(1u, 2u, 3u).associateWith { it.toString() }
|
|
)
|
|
assertEquals(
|
|
mapOf(1.toUByte() to "1", 2.toUByte() to "2", 3.toUByte() to "3"),
|
|
ubyteArrayOf(1u, 2u, 3u).associateWith { it.toString() }
|
|
)
|
|
assertEquals(
|
|
mapOf(1.toUShort() to "1", 2.toUShort() to "2", 3.toUShort() to "3"),
|
|
ushortArrayOf(1u, 2u, 3u).associateWith { it.toString() }
|
|
)
|
|
assertEquals(
|
|
mapOf(1UL to "1", 2UL to "2", 3UL to "3"),
|
|
ulongArrayOf(1u, 2u, 3u).associateWith { it.toString() }
|
|
)
|
|
}
|
|
|
|
@Test
|
|
fun associateWithToPrimitives() {
|
|
val expected = mapOf(1u to "one", 2u to "two", 3u to "three")
|
|
assertEquals(
|
|
mapOf(1u to "one", 2u to "2", 3u to "3"),
|
|
uintArrayOf(2u, 3u).associateWithTo(expected.toMutableMap()) { it.toString() }
|
|
)
|
|
assertEquals(
|
|
mapOf(1.toUByte() to "one", 2.toUByte() to "2", 3.toUByte() to "3"),
|
|
ubyteArrayOf(2u, 3u).associateWithTo(expected.mapKeys { it.key.toUByte() }.toMutableMap()) { it.toString() }
|
|
)
|
|
assertEquals(
|
|
mapOf(1.toUShort() to "one", 2.toUShort() to "2", 3.toUShort() to "3"),
|
|
ushortArrayOf(2u, 3u).associateWithTo(expected.mapKeys { it.key.toUShort() }.toMutableMap()) { it.toString() }
|
|
)
|
|
assertEquals(
|
|
mapOf(1UL to "one", 2UL to "2", 3UL to "3"),
|
|
ulongArrayOf(2u, 3u).associateWithTo(expected.mapKeys { it.key.toULong() }.toMutableMap()) { it.toString() }
|
|
)
|
|
}
|
|
|
|
@Test
|
|
fun elementAt() {
|
|
expect(0u) { ubyteArrayOf(0u, 1u, 2u).elementAt(0) }
|
|
expect(1u) { ushortArrayOf(0u, 1u, 2u).elementAt(1) }
|
|
expect(2u) { uintArrayOf(0u, 1u, 2u).elementAt(2) }
|
|
|
|
assertFailsWith<IndexOutOfBoundsException> { uintArrayOf().elementAt(0) }
|
|
assertFailsWith<IndexOutOfBoundsException> { ulongArrayOf(0u, 1u, 2u).elementAt(-1) }
|
|
}
|
|
|
|
@Test
|
|
fun elementAtOrElse() {
|
|
expect(0u) { ubyteArrayOf(0u, 1u, 2u).elementAtOrElse(0) { UByte.MAX_VALUE } }
|
|
expect(UShort.MAX_VALUE) { ushortArrayOf(0u, 1u, 2u).elementAtOrElse(-1) { UShort.MAX_VALUE } }
|
|
expect(UInt.MAX_VALUE) { uintArrayOf(0u, 1u, 2u).elementAtOrElse(3) { UInt.MAX_VALUE } }
|
|
expect(ULong.MAX_VALUE) { ulongArrayOf(0u, 1u, 2u).elementAtOrElse(100) { ULong.MAX_VALUE } }
|
|
}
|
|
|
|
@Test
|
|
fun elementAtOrNull() {
|
|
expect(0u) { ubyteArrayOf(0u, 1u, 2u).elementAtOrNull(0) }
|
|
expect(null) { ushortArrayOf(0u, 1u, 2u).elementAtOrNull(-1) }
|
|
expect(null) { uintArrayOf(0u, 1u, 2u).elementAtOrNull(3) }
|
|
expect(null) { ulongArrayOf(0u, 1u, 2u).elementAtOrNull(100) }
|
|
}
|
|
|
|
@Test
|
|
fun find() {
|
|
expect(0u) { ubyteArrayOf(0u, 1u, 2u).find { it == 0.toUByte() } }
|
|
expect(0u) { ushortArrayOf(0u, 1u, 2u).find { it % 2u == 0u } }
|
|
expect(1u) { uintArrayOf(0u, 1u, 2u).find { it % 2u == 1u } }
|
|
expect(null) { ulongArrayOf(0u, 1u, 2u).find { it == 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun findLast() {
|
|
expect(0u) { ubyteArrayOf(0u, 1u, 2u).findLast { it == 0.toUByte() } }
|
|
expect(2u) { ushortArrayOf(0u, 1u, 2u).findLast { it % 2u == 0u } }
|
|
expect(1u) { uintArrayOf(0u, 1u, 2u).findLast { it % 2u == 1u } }
|
|
expect(null) { ulongArrayOf(0u, 1u, 2u).findLast { it == 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun first() {
|
|
expect(0u) { ubyteArrayOf(0u, 1u, 2u).first() }
|
|
expect(0u) { ushortArrayOf(0u, 1u, 2u).first { it % 2u == 0u } }
|
|
expect(1u) { uintArrayOf(0u, 1u, 2u).first { it % 2u == 1u } }
|
|
assertFailsWith<NoSuchElementException> { uintArrayOf().first() }
|
|
assertFailsWith<NoSuchElementException> { ulongArrayOf(0u, 1u, 2u).first { it == 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun firstOrNull() {
|
|
expect(0u) { ubyteArrayOf(0u, 1u, 2u).firstOrNull() }
|
|
expect(0u) { ushortArrayOf(0u, 1u, 2u).firstOrNull { it % 2u == 0u } }
|
|
expect(1u) { uintArrayOf(0u, 1u, 2u).firstOrNull { it % 2u == 1u } }
|
|
expect(null) { uintArrayOf().firstOrNull() }
|
|
expect(null) { ulongArrayOf(0u, 1u, 2u).firstOrNull { it == 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun getOrElse() {
|
|
expect(0u) { ubyteArrayOf(0u, 1u, 2u).getOrElse(0) { UByte.MAX_VALUE } }
|
|
expect(UShort.MAX_VALUE) { ushortArrayOf(0u, 1u, 2u).getOrElse(-1) { UShort.MAX_VALUE } }
|
|
expect(UInt.MAX_VALUE) { uintArrayOf(0u, 1u, 2u).getOrElse(3) { UInt.MAX_VALUE } }
|
|
expect(ULong.MAX_VALUE) { ulongArrayOf(0u, 1u, 2u).getOrElse(100) { ULong.MAX_VALUE } }
|
|
}
|
|
|
|
@Test
|
|
fun getOrNull() {
|
|
expect(0u) { ubyteArrayOf(0u, 1u, 2u).getOrNull(0) }
|
|
expect(null) { ushortArrayOf(0u, 1u, 2u).getOrNull(-1) }
|
|
expect(null) { uintArrayOf(0u, 1u, 2u).getOrNull(3) }
|
|
expect(null) { ulongArrayOf(0u, 1u, 2u).getOrNull(100) }
|
|
}
|
|
|
|
@Test
|
|
fun last() {
|
|
expect(2u) { ubyteArrayOf(0u, 1u, 2u).last() }
|
|
expect(2u) { ushortArrayOf(0u, 1u, 2u).last { it % 2u == 0u } }
|
|
expect(1u) { uintArrayOf(0u, 1u, 2u).last { it % 2u == 1u } }
|
|
assertFailsWith<NoSuchElementException> { uintArrayOf().last() }
|
|
assertFailsWith<NoSuchElementException> { ulongArrayOf(0u, 1u, 2u).last { it == 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun lastOrNull() {
|
|
expect(2u) { ubyteArrayOf(0u, 1u, 2u).lastOrNull() }
|
|
expect(2u) { ushortArrayOf(0u, 1u, 2u).lastOrNull { it % 2u == 0u } }
|
|
expect(1u) { uintArrayOf(0u, 1u, 2u).lastOrNull { it % 2u == 1u } }
|
|
expect(null) { uintArrayOf().lastOrNull() }
|
|
expect(null) { ulongArrayOf(0u, 1u, 2u).lastOrNull { it == 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun single() {
|
|
expect(0u) { ubyteArrayOf(0u).single() }
|
|
expect(2u) { ushortArrayOf(0u, 1u, 2u).single { it == 2.toUShort() } }
|
|
expect(1u) { uintArrayOf(0u, 1u, 2u).single { it % 2u == 1u } }
|
|
assertFailsWith<NoSuchElementException> { uintArrayOf().single() }
|
|
assertFailsWith<NoSuchElementException> { ulongArrayOf(0u, 1u, 2u).single { it == 3uL } }
|
|
assertFailsWith<IllegalArgumentException> { ulongArrayOf(0u, 1u, 2u).single { it % 2uL == 0uL } }
|
|
}
|
|
|
|
@Test
|
|
fun singleOrNull() {
|
|
expect(0u) { ubyteArrayOf(0u).singleOrNull() }
|
|
expect(2u) { ushortArrayOf(0u, 1u, 2u).singleOrNull { it == 2.toUShort() } }
|
|
expect(1u) { uintArrayOf(0u, 1u, 2u).singleOrNull { it % 2u == 1u } }
|
|
expect(null) { uintArrayOf().singleOrNull() }
|
|
expect(null) { ulongArrayOf(0u, 1u, 2u).singleOrNull { it % 2uL == 0uL } }
|
|
}
|
|
|
|
@Test
|
|
fun map() {
|
|
assertEquals(listOf(), ubyteArrayOf().map { it })
|
|
assertEquals(listOf<UShort>(1u, 2u, 3u), ushortArrayOf(1u, 2u, 3u).map { it })
|
|
assertEquals(listOf<UInt>(2u, 4u, 6u), uintArrayOf(1u, 2u, 3u).map { 2u * it })
|
|
assertEquals(listOf<ULong>(0u, 0u, 0u), ulongArrayOf(1u, 2u, 3u).map { 0uL })
|
|
}
|
|
|
|
@Test
|
|
fun mapIndexed() {
|
|
assertEquals(listOf(), ubyteArrayOf().mapIndexed { _, e -> e })
|
|
assertEquals(listOf<UShort>(1u, 2u, 3u), ushortArrayOf(1u, 2u, 3u).mapIndexed { _, e -> e })
|
|
assertEquals(listOf(0, 1, 2), uintArrayOf(1u, 2u, 3u).mapIndexed { index, _ -> index })
|
|
assertEquals(listOf(0, 0, 0), ulongArrayOf(1u, 2u, 3u).mapIndexed { _, _ -> 0 })
|
|
}
|
|
|
|
@Test
|
|
fun groupBy() {
|
|
assertEquals(mapOf(), ubyteArrayOf().groupBy { k -> k })
|
|
assertEquals(
|
|
mapOf(
|
|
1.toUShort() to listOf<UShort>(1u),
|
|
2.toUShort() to listOf<UShort>(2u),
|
|
3.toUShort() to listOf<UShort>(3u)
|
|
),
|
|
ushortArrayOf(1u, 2u, 3u).groupBy { k -> k }
|
|
)
|
|
assertEquals(
|
|
mapOf(
|
|
0.toUInt() to listOf("2"),
|
|
1.toUInt() to listOf("1", "3")
|
|
),
|
|
uintArrayOf(1u, 2u, 3u).groupBy({ k -> k % 2u }, { v -> v.toString() })
|
|
)
|
|
assertEquals(
|
|
mapOf(
|
|
0 to listOf(0, 0, 0)
|
|
),
|
|
ulongArrayOf(1u, 2u, 3u).groupBy({ 0 }, { 0 })
|
|
)
|
|
}
|
|
|
|
@Test
|
|
fun flatMap() {
|
|
assertEquals(listOf(), ubyteArrayOf().flatMap { listOf(it) })
|
|
assertEquals(listOf<UShort>(1u, 2u, 3u), ushortArrayOf(1u, 2u, 3u).flatMap { listOf(it) })
|
|
assertEquals(listOf<UInt>(1u, 1u, 2u, 2u, 3u, 3u), uintArrayOf(1u, 2u, 3u).flatMap { listOf(it, it) })
|
|
assertEquals(listOf(), ulongArrayOf(1u, 2u, 3u).flatMap { listOf<ULong>() })
|
|
}
|
|
|
|
@Test
|
|
fun flatMapIndexed() {
|
|
assertEquals(listOf(), ubyteArrayOf().flatMapIndexed { index, _ -> listOf(index) })
|
|
assertEquals(listOf<UShort>(2u, 3u, 3u), ushortArrayOf(1u, 2u, 3u).flatMapIndexed { index, e -> List(index) { e } })
|
|
assertEquals(listOf<UInt>(2u, 2u, 3u, 3u, 3u, 3u), uintArrayOf(1u, 2u, 3u).flatMapIndexed { index, e -> List(index * 2) { e } })
|
|
assertEquals(listOf(), ulongArrayOf(1u, 2u, 3u).flatMapIndexed { _, _ -> listOf<ULong>() })
|
|
}
|
|
|
|
@Test
|
|
fun withIndex() {
|
|
fun <T> assertIterableContentEquals(expected: Iterable<T>, actual: Iterable<T>) {
|
|
compare(expected.iterator(), actual.iterator()) { iteratorBehavior() }
|
|
}
|
|
|
|
assertIterableContentEquals(listOf(), ubyteArrayOf().withIndex())
|
|
assertIterableContentEquals(
|
|
listOf(
|
|
IndexedValue(0, 1.toUShort()),
|
|
IndexedValue(1, 2.toUShort()),
|
|
IndexedValue(2, 3.toUShort())
|
|
),
|
|
ushortArrayOf(1u, 2u, 3u).withIndex()
|
|
)
|
|
assertEquals(IndexedValue(1, 2.toUInt()), uintArrayOf(1u, 2u, 3u).withIndex().minByOrNull { it.value % 2u })
|
|
assertIterableContentEquals(listOf(0, 1, 2), ulongArrayOf(1u, 2u, 3u).withIndex().map { it.index })
|
|
}
|
|
|
|
@Test
|
|
fun zip() {
|
|
assertEquals(listOf(), ubyteArrayOf().zip(ubyteArrayOf()))
|
|
assertEquals(
|
|
listOf(
|
|
1.toUShort() to 1.toUShort(),
|
|
2.toUShort() to 2.toUShort()
|
|
),
|
|
ushortArrayOf(1u, 2u, 3u).zip(ushortArrayOf(1u, 2u))
|
|
)
|
|
assertEquals(
|
|
listOf("1a", "2b", "3c"),
|
|
uintArrayOf(1u, 2u, 3u).zip(arrayOf("a", "b", "c", "d")) { a, b -> a.toString() + b }
|
|
)
|
|
assertEquals(
|
|
listOf<ULong>(11u, 12u, 13u),
|
|
ulongArrayOf(1u, 2u, 3u).zip(listOf<ULong>(10u, 10u, 10u)) { a, b -> a + b }
|
|
)
|
|
}
|
|
|
|
@Test
|
|
fun onEach() {
|
|
assertEquals(listOf<UInt>(1u, 2u, 3u), mutableListOf<UInt>().apply { uintArrayOf(1u, 2u, 3u).onEach { add(it) } })
|
|
assertEquals(listOf<UByte>(1u, 2u, 3u), mutableListOf<UByte>().apply { ubyteArrayOf(1u, 2u, 3u).onEach { add(it) } })
|
|
assertEquals(listOf<UShort>(1u, 2u, 3u), mutableListOf<UShort>().apply { ushortArrayOf(1u, 2u, 3u).onEach { add(it) } })
|
|
assertEquals(listOf<ULong>(1u, 2u, 3u), mutableListOf<ULong>().apply { ulongArrayOf(1u, 2u, 3u).onEach { add(it) } })
|
|
}
|
|
|
|
@Test
|
|
fun onEachIndexed() {
|
|
assertEquals(listOf<UInt>(1u, 3u, 5u), mutableListOf<UInt>().apply { uintArrayOf(1u, 2u, 3u).onEachIndexed { i, e -> add(i.toUInt() + e) } })
|
|
assertEquals(listOf<UInt>(1u, 3u, 5u), mutableListOf<UInt>().apply { ubyteArrayOf(1u, 2u, 3u).onEachIndexed { i, e -> add(i.toUByte() + e) } })
|
|
assertEquals(listOf<UInt>(1u, 3u, 5u), mutableListOf<UInt>().apply { ushortArrayOf(1u, 2u, 3u).onEachIndexed { i, e -> add(i.toUShort() + e) } })
|
|
assertEquals(listOf<ULong>(1u, 3u, 5u), mutableListOf<ULong>().apply { ulongArrayOf(1u, 2u, 3u).onEachIndexed { i, e -> add(i.toULong() + e) } })
|
|
|
|
val empty = arrayOf<UInt>()
|
|
assertSame(empty, empty.onEachIndexed { i, e -> fail("Should be unreachable: $i, $e") })
|
|
|
|
// Identity equality for arguments of types ULongArray and ULongArray is forbidden
|
|
// val nonEmpty = ulongArrayOf(1, 2, 3)
|
|
// assertSame(nonEmpty, nonEmpty.onEachIndexed { _, _ -> })
|
|
}
|
|
|
|
@Test
|
|
fun drop() {
|
|
expect(listOf(1.toUByte())) { ubyteArrayOf(1u).drop(0) }
|
|
expect(listOf()) { ushortArrayOf().drop(1) }
|
|
expect(listOf()) { uintArrayOf(1u).drop(1) }
|
|
expect(listOf(3uL)) { ulongArrayOf(2u, 3u).drop(1) }
|
|
assertFails {
|
|
uintArrayOf(2u).drop(-1)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun dropLast() {
|
|
expect(listOf()) { ubyteArrayOf().dropLast(1) }
|
|
expect(listOf()) { ushortArrayOf(1u).dropLast(1) }
|
|
expect(listOf(1u)) { uintArrayOf(1u).dropLast(0) }
|
|
expect(listOf(2uL)) { ulongArrayOf(2u, 3u).dropLast(1) }
|
|
assertFails {
|
|
ulongArrayOf(1u).dropLast(-1)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun dropWhile() {
|
|
expect(listOf(3.toUByte(), 1.toUByte())) { ubyteArrayOf(2u, 3u, 1u).dropWhile { it < 3u } }
|
|
expect(listOf()) { ushortArrayOf().dropWhile { it < 3u } }
|
|
expect(listOf()) { uintArrayOf(1u).dropWhile { it < 3u } }
|
|
expect(listOf(3uL, 1uL)) { ulongArrayOf(2u, 3u, 1u).dropWhile { it < 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun dropLastWhile() {
|
|
expect(listOf(2.toUByte(), 3.toUByte())) { ubyteArrayOf(2u, 3u, 1u).dropLastWhile { it < 3u } }
|
|
expect(listOf()) { ushortArrayOf().dropLastWhile { it < 3u } }
|
|
expect(listOf()) { uintArrayOf(1u).dropLastWhile { it < 3u } }
|
|
expect(listOf(2uL, 3uL)) { ulongArrayOf(2u, 3u, 1u).dropLastWhile { it < 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun take() {
|
|
expect(listOf()) { ubyteArrayOf().take(1) }
|
|
expect(listOf()) { ushortArrayOf(1u).take(0) }
|
|
expect(listOf(1u)) { uintArrayOf(1u).take(1) }
|
|
expect(listOf(2uL)) { ulongArrayOf(2u, 3u).take(1) }
|
|
assertFails {
|
|
ubyteArrayOf(1u).take(-1)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun takeLast() {
|
|
expect(listOf()) { ubyteArrayOf().takeLast(1) }
|
|
expect(listOf()) { ushortArrayOf(1u).takeLast(0) }
|
|
expect(listOf(1u)) { uintArrayOf(1u).takeLast(1) }
|
|
expect(listOf(3uL)) { ulongArrayOf(2u, 3u).takeLast(1) }
|
|
assertFails {
|
|
ushortArrayOf(1u).takeLast(-1)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun takeWhile() {
|
|
expect(listOf(2.toUByte())) { ubyteArrayOf(2u, 3u, 1u).takeWhile { it < 3u } }
|
|
expect(listOf()) { ushortArrayOf().takeWhile { it < 3u } }
|
|
expect(listOf(1u)) { uintArrayOf(1u).takeWhile { it < 3u } }
|
|
expect(listOf(2uL)) { ulongArrayOf(2u, 3u, 1u).takeWhile { it < 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun takeLastWhile() {
|
|
expect(listOf()) { ubyteArrayOf().takeLastWhile { it < 3u } }
|
|
expect(listOf(1.toUShort())) { ushortArrayOf(1u).takeLastWhile { it < 3u } }
|
|
expect(listOf(1u)) { uintArrayOf(2u, 3u, 1u).takeLastWhile { it < 3u } }
|
|
expect(listOf(1uL)) { ulongArrayOf(2u, 3u, 1u).takeLastWhile { it < 3uL } }
|
|
}
|
|
|
|
@Test
|
|
fun filter() {
|
|
expect(listOf(3.toByte())) { byteArrayOf(2, 3).filter { it > 2 } }
|
|
expect(listOf()) { ushortArrayOf().filter { it > 2u } }
|
|
expect(listOf()) { uintArrayOf(1u).filter { it > 2u } }
|
|
expect(listOf(3uL)) { ulongArrayOf(2u, 3u).filter { it > 2uL } }
|
|
}
|
|
|
|
@Test
|
|
fun filterIndexed() {
|
|
expect(listOf<UByte>(2u, 5u, 8u)) {
|
|
ubyteArrayOf(2u, 4u, 3u, 5u, 8u).filterIndexed { index, value -> index % 2 == (value % 2u).toInt() }
|
|
}
|
|
expect(listOf()) {
|
|
ushortArrayOf().filterIndexed { i, v -> i > v.toInt() }
|
|
}
|
|
expect(listOf(2u, 5u, 8u)) {
|
|
uintArrayOf(2u, 4u, 3u, 5u, 8u).filterIndexed { index, value -> index % 2 == (value % 2u).toInt() }
|
|
}
|
|
expect(listOf<ULong>(2u, 5u, 8u)) {
|
|
ulongArrayOf(2u, 4u, 3u, 5u, 8u).filterIndexed { index, value -> index % 2 == (value % 2uL).toInt() }
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun filterNot() {
|
|
expect(listOf(2.toUByte())) { ubyteArrayOf(2u, 3u).filterNot { it > 2u } }
|
|
expect(listOf()) { ushortArrayOf().filterNot { it > 2u } }
|
|
expect(listOf(1u)) { uintArrayOf(1u).filterNot { it > 2u } }
|
|
expect(listOf(2uL)) { ulongArrayOf(2u, 3u).filterNot { it > 2uL } }
|
|
}
|
|
|
|
@Test
|
|
fun sort() {
|
|
val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u)
|
|
assertArrayContentEquals(ubyteArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 250u, UByte.MAX_VALUE), ubyteArray.apply { sort() })
|
|
|
|
val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u)
|
|
assertArrayContentEquals(ushortArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 65501u, UShort.MAX_VALUE), ushortArray.apply { sort() })
|
|
|
|
val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u)
|
|
assertArrayContentEquals(uintArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 4294967200u, UInt.MAX_VALUE), uintArray.apply { sort() })
|
|
|
|
val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u)
|
|
assertArrayContentEquals(ulongArrayOf(0u, 1u, 2u, 5u, 9u, 80u, ULong.MAX_VALUE - 123u, ULong.MAX_VALUE), ulongArray.apply { sort() })
|
|
}
|
|
|
|
@Test
|
|
fun sortDescending() {
|
|
val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u)
|
|
assertArrayContentEquals(ubyteArrayOf(UByte.MAX_VALUE, 250u, 80u, 9u, 5u, 2u, 1u, 0u), ubyteArray.apply { sortDescending() })
|
|
|
|
val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u)
|
|
assertArrayContentEquals(ushortArrayOf(UShort.MAX_VALUE, 65501u, 80u, 9u, 5u, 2u, 1u, 0u), ushortArray.apply { sortDescending() })
|
|
|
|
val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u)
|
|
assertArrayContentEquals(uintArrayOf(UInt.MAX_VALUE, 4294967200u, 80u, 9u, 5u, 2u, 1u, 0u), uintArray.apply { sortDescending() })
|
|
|
|
val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u)
|
|
assertArrayContentEquals(ulongArrayOf(ULong.MAX_VALUE, ULong.MAX_VALUE - 123u, 80u, 9u, 5u, 2u, 1u, 0u), ulongArray.apply { sortDescending() })
|
|
}
|
|
|
|
@Test
|
|
fun sorted() {
|
|
assertTrue(uintArrayOf().sorted().none())
|
|
assertEquals(listOf(1u), uintArrayOf(1u).sorted())
|
|
|
|
val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u)
|
|
assertEquals(listOf<UByte>(0u, 1u, 2u, 5u, 9u, 80u, 250u, UByte.MAX_VALUE), ubyteArray.sorted())
|
|
|
|
val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u)
|
|
assertEquals(listOf<UShort>(0u, 1u, 2u, 5u, 9u, 80u, 65501u, UShort.MAX_VALUE), ushortArray.sorted())
|
|
|
|
val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u)
|
|
assertEquals(listOf<UInt>(0u, 1u, 2u, 5u, 9u, 80u, 4294967200u, UInt.MAX_VALUE), uintArray.sorted())
|
|
|
|
val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u)
|
|
assertEquals(listOf<ULong>(0u, 1u, 2u, 5u, 9u, 80u, ULong.MAX_VALUE - 123u, ULong.MAX_VALUE), ulongArray.sorted())
|
|
}
|
|
|
|
@Test
|
|
fun sortedDescending() {
|
|
assertTrue(uintArrayOf().sortedDescending().none())
|
|
assertEquals(listOf(1u), uintArrayOf(1u).sortedDescending())
|
|
|
|
val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u)
|
|
assertEquals(listOf<UByte>(UByte.MAX_VALUE, 250u, 80u, 9u, 5u, 2u, 1u, 0u), ubyteArray.sortedDescending())
|
|
|
|
val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u)
|
|
assertEquals(listOf<UShort>(UShort.MAX_VALUE, 65501u, 80u, 9u, 5u, 2u, 1u, 0u), ushortArray.sortedDescending())
|
|
|
|
val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u)
|
|
assertEquals(listOf<UInt>(UInt.MAX_VALUE, 4294967200u, 80u, 9u, 5u, 2u, 1u, 0u), uintArray.sortedDescending())
|
|
|
|
val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u)
|
|
assertEquals(listOf<ULong>(ULong.MAX_VALUE, ULong.MAX_VALUE - 123u, 80u, 9u, 5u, 2u, 1u, 0u), ulongArray.sortedDescending())
|
|
}
|
|
|
|
@Test
|
|
fun sortedBy() {
|
|
assertTrue(uintArrayOf().sortedBy { it.toString() }.none())
|
|
assertEquals(listOf(1u), uintArrayOf(1u).sortedBy { it.toString() })
|
|
|
|
val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u)
|
|
assertEquals(listOf<UByte>(250u, UByte.MAX_VALUE, 0u, 1u, 2u, 5u, 9u, 80u), ubyteArray.sortedBy { it.toByte() })
|
|
|
|
val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u)
|
|
assertEquals(listOf<UShort>(65501u, UShort.MAX_VALUE, 0u, 1u, 2u, 5u, 9u, 80u), ushortArray.sortedBy { it.toShort() })
|
|
|
|
val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u)
|
|
assertEquals(listOf<UInt>(4294967200u, UInt.MAX_VALUE, 0u, 1u, 2u, 5u, 9u, 80u), uintArray.sortedBy { it.toInt() })
|
|
|
|
val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u)
|
|
assertEquals(listOf<ULong>(ULong.MAX_VALUE - 123u, ULong.MAX_VALUE, 0u, 1u, 2u, 5u, 9u, 80u), ulongArray.sortedBy { it.toLong() })
|
|
}
|
|
|
|
@Test
|
|
fun sortedArray() {
|
|
val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u)
|
|
assertArrayContentEquals(ubyteArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 250u, UByte.MAX_VALUE), ubyteArray.sortedArray())
|
|
|
|
val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u)
|
|
assertArrayContentEquals(ushortArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 65501u, UShort.MAX_VALUE), ushortArray.sortedArray())
|
|
|
|
val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u)
|
|
assertArrayContentEquals(uintArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 4294967200u, UInt.MAX_VALUE), uintArray.sortedArray())
|
|
|
|
val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u)
|
|
assertArrayContentEquals(ulongArrayOf(0u, 1u, 2u, 5u, 9u, 80u, ULong.MAX_VALUE - 123u, ULong.MAX_VALUE), ulongArray.sortedArray())
|
|
}
|
|
|
|
@Test
|
|
fun sortedArrayDescending() {
|
|
val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u)
|
|
assertArrayContentEquals(ubyteArrayOf(UByte.MAX_VALUE, 250u, 80u, 9u, 5u, 2u, 1u, 0u), ubyteArray.sortedArrayDescending())
|
|
|
|
val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u)
|
|
assertArrayContentEquals(ushortArrayOf(UShort.MAX_VALUE, 65501u, 80u, 9u, 5u, 2u, 1u, 0u), ushortArray.sortedArrayDescending())
|
|
|
|
val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u)
|
|
assertArrayContentEquals(uintArrayOf(UInt.MAX_VALUE, 4294967200u, 80u, 9u, 5u, 2u, 1u, 0u), uintArray.sortedArrayDescending())
|
|
|
|
val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u)
|
|
assertArrayContentEquals(ulongArrayOf(ULong.MAX_VALUE, ULong.MAX_VALUE - 123u, 80u, 9u, 5u, 2u, 1u, 0u), ulongArray.sortedArrayDescending())
|
|
}
|
|
|
|
@Test
|
|
fun fill() {
|
|
fun <A, E> testFailures(array: A, fill: A.(E, Int, Int) -> Unit, element: E, arraySize: Int) {
|
|
assertFailsWith<IndexOutOfBoundsException> {
|
|
array.fill(element, -1, arraySize)
|
|
}
|
|
assertFailsWith<IndexOutOfBoundsException> {
|
|
array.fill(element, 0, arraySize + 1)
|
|
}
|
|
assertFailsWith<IllegalArgumentException> {
|
|
array.fill(element, 1, 0)
|
|
}
|
|
}
|
|
|
|
testFailures(UByteArray(5) { it.toUByte() }, UByteArray::fill, 0u, 5)
|
|
testFailures(UShortArray(5) { it.toUShort() }, UShortArray::fill, 0u, 5)
|
|
testFailures(UIntArray(5) { it.toUInt() }, UIntArray::fill, 0u, 5)
|
|
testFailures(ULongArray(5) { it.toULong() }, ULongArray::fill, 0u, 5)
|
|
|
|
fun <A, E> test(
|
|
array: UIntArray,
|
|
fill: A.(E, Int, Int) -> Unit,
|
|
operations: List<OperationOnRange<UInt, UIntArray>>,
|
|
arrayTransform: UIntArray.() -> A,
|
|
elementTransform: UInt.() -> E,
|
|
contentEquals: A.(A) -> Boolean
|
|
) {
|
|
for (o in operations) {
|
|
val result = array.arrayTransform()
|
|
result.fill(o.element.elementTransform(), o.fromIndex, o.toIndex)
|
|
assertTrue(o.expectedResult.arrayTransform().contentEquals(result))
|
|
}
|
|
}
|
|
|
|
val array = UIntArray(5) { it.toUInt() }
|
|
|
|
val operations = listOf(
|
|
OperationOnRange(5u, 1, 4, uintArrayOf(0u, 5u, 5u, 5u, 4u)),
|
|
OperationOnRange(1u, 0, 5, uintArrayOf(1u, 1u, 1u, 1u, 1u)),
|
|
OperationOnRange(2u, 0, 3, uintArrayOf(2u, 2u, 2u, 3u, 4u)),
|
|
OperationOnRange(3u, 2, 5, uintArrayOf(0u, 1u, 3u, 3u, 3u))
|
|
)
|
|
|
|
test(array, UByteArray::fill, operations, UIntArray::toUByteArray, UInt::toUByte, UByteArray::contentEquals)
|
|
test(array, UShortArray::fill, operations, UIntArray::toUShortArray, UInt::toUShort, UShortArray::contentEquals)
|
|
test(array, UIntArray::fill, operations, UIntArray::copyOf, UInt::toUInt, UIntArray::contentEquals)
|
|
test(array, ULongArray::fill, operations, UIntArray::toULongArray, UInt::toULong, ULongArray::contentEquals)
|
|
}
|
|
|
|
private class OperationOnRange<E, R>(
|
|
val element: E,
|
|
val fromIndex: Int,
|
|
val toIndex: Int,
|
|
val expectedResult: R
|
|
)
|
|
}
|
|
|
|
|
|
private fun UIntArray.toUByteArray(): UByteArray {
|
|
return UByteArray(size) { get(it).toUByte() }
|
|
}
|
|
|
|
private fun UIntArray.toUShortArray(): UShortArray {
|
|
return UShortArray(size) { get(it).toUShort() }
|
|
}
|
|
|
|
private fun UIntArray.toULongArray(): ULongArray {
|
|
return ULongArray(size) { get(it).toULong() }
|
|
}
|