Generate some tests
diff --git a/libraries/stdlib/test/OrderingTest.kt b/libraries/stdlib/test/OrderingTest.kt index c32fa1e..3278d34 100644 --- a/libraries/stdlib/test/OrderingTest.kt +++ b/libraries/stdlib/test/OrderingTest.kt
@@ -152,24 +152,6 @@ } @Test - fun maxOf() { - assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE)) - assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE, 0)) - assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE, 0, -1)) - - assertEquals(Long.MAX_VALUE, maxOf(Long.MAX_VALUE, Long.MIN_VALUE)) - assertEquals(Long.MAX_VALUE, maxOf(Long.MAX_VALUE, Long.MIN_VALUE, 0)) - assertEquals(Long.MAX_VALUE, maxOf(Long.MAX_VALUE, Long.MIN_VALUE, 0, -1)) - - assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY)) - assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) - assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) - assertEquals(0.0, maxOf(0.0, -0.0)) - assertEquals(0.0, maxOf(-0.0, 0.0)) - assertEquals(0.0, maxOf(-0.0, 0.0, 0.0, -0.0)) - } - - @Test fun maxOfWith() { assertEquals(v1, maxOf(v1, v2, compareBy { it.name })) assertEquals(v1, maxOf(v3, v2, v1, compareBy { it.name })) @@ -180,24 +162,6 @@ } @Test - fun minOf() { - assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE)) - assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE, 0)) - assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE, 0, -1)) - - assertEquals(Long.MIN_VALUE, minOf(Long.MAX_VALUE, Long.MIN_VALUE)) - assertEquals(Long.MIN_VALUE, minOf(Long.MAX_VALUE, Long.MIN_VALUE, 0)) - assertEquals(Long.MIN_VALUE, minOf(Long.MAX_VALUE, Long.MIN_VALUE, 0, -1)) - - assertEquals(Double.NEGATIVE_INFINITY, minOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY)) - assertEquals(Double.MIN_VALUE, minOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) - assertEquals(Double.NEGATIVE_INFINITY, minOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) - assertEquals(-0.0, minOf(0.0, -0.0)) - assertEquals(-0.0, minOf(-0.0, 0.0)) - assertEquals(-0.0, minOf(-0.0, 0.0, 0.0, -0.0)) - } - - @Test fun minOfWith() { assertEquals(v2, minOf(v1, v2, compareBy { it.name })) assertEquals(v3, minOf(v3, v2, v1, compareBy { it.name }))
diff --git a/libraries/stdlib/test/collections/ArraysTest.kt b/libraries/stdlib/test/collections/ArraysTest.kt index 8e5ce86..faa0b95 100644 --- a/libraries/stdlib/test/collections/ArraysTest.kt +++ b/libraries/stdlib/test/collections/ArraysTest.kt
@@ -8,7 +8,6 @@ package test.collections import test.assertStaticTypeIs -import test.assertTypeEquals import test.collections.behaviors.* import test.comparisons.STRING_CASE_INSENSITIVE_ORDER import test.text.isAsciiLetter @@ -389,66 +388,6 @@ expect('b', { charArrayOf('a', 'b').maxOrNull() }) } - @Test fun minWithOrNull() { - assertEquals(null, arrayOf<Int>().minWithOrNull(naturalOrder())) - assertEquals("a", arrayOf("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) - } - - @Test fun minWithOrNullInPrimitiveArrays() { - expect(null, { intArrayOf().minWithOrNull(naturalOrder()) }) - expect(1, { intArrayOf(1).minWithOrNull(naturalOrder()) }) - expect(4, { intArrayOf(2, 3, 4).minWithOrNull(compareBy { it % 4 }) }) - } - - @Test fun maxWithOrNull() { - assertEquals(null, arrayOf<Int>().maxWithOrNull(naturalOrder())) - assertEquals("B", arrayOf("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) - } - - @Test fun maxWithOrNullInPrimitiveArrays() { - expect(null, { intArrayOf().maxWithOrNull(naturalOrder()) }) - expect(1, { intArrayOf(1).maxWithOrNull(naturalOrder()) }) - expect(-4, { intArrayOf(2, 3, -4).maxWithOrNull(compareBy { it * it }) }) - } - - @Test fun minByOrNull() { - expect(null, { arrayOf<Int>().minByOrNull { it } }) - expect(1, { arrayOf(1).minByOrNull { it } }) - expect(3, { arrayOf(2, 3).minByOrNull { -it } }) - expect('a', { arrayOf('a', 'b').minByOrNull { "x$it" } }) - expect("b", { arrayOf("b", "abc").minByOrNull { it.length } }) - } - - @Test fun minByOrNullInPrimitiveArrays() { - expect(null, { intArrayOf().minByOrNull { it } }) - expect(1, { intArrayOf(1).minByOrNull { it } }) - expect(3, { intArrayOf(2, 3).minByOrNull { -it } }) - expect(2000000000000, { longArrayOf(3000000000000, 2000000000000).minByOrNull { it + 1 } }) - expect(1, { byteArrayOf(1, 3, 2).minByOrNull { it * it } }) - expect(3, { shortArrayOf(3, 2).minByOrNull { "a" } }) - expect(2.0F, { floatArrayOf(3.0F, 2.0F).minByOrNull { it.toString() } }) - expect(2.0, { doubleArrayOf(2.0, 3.0).minByOrNull { it * it } }) - } - - @Test fun maxByOrNull() { - expect(null, { arrayOf<Int>().maxByOrNull { it } }) - expect(1, { arrayOf(1).maxByOrNull { it } }) - expect(2, { arrayOf(2, 3).maxByOrNull { -it } }) - expect('b', { arrayOf('a', 'b').maxByOrNull { "x$it" } }) - expect("abc", { arrayOf("b", "abc").maxByOrNull { it.length } }) - } - - @Test fun maxByOrNullInPrimitiveArrays() { - expect(null, { intArrayOf().maxByOrNull { it } }) - expect(1, { intArrayOf(1).maxByOrNull { it } }) - expect(2, { intArrayOf(2, 3).maxByOrNull { -it } }) - expect(3000000000000, { longArrayOf(3000000000000, 2000000000000).maxByOrNull { it + 1 } }) - expect(3, { byteArrayOf(1, 3, 2).maxByOrNull { it * it } }) - expect(3, { shortArrayOf(3, 2).maxByOrNull { "a" } }) - expect(3.0F, { floatArrayOf(3.0F, 2.0F).maxByOrNull { it.toString() } }) - expect(3.0, { doubleArrayOf(2.0, 3.0).maxByOrNull { it * it } }) - } - @Test fun minIndex() { val a = intArrayOf(1, 7, 9, -42, 54, 93) expect(3, { a.indices.minByOrNull { a[it] } }) @@ -502,66 +441,6 @@ // for each arr with size > 0 arr.average() = arr.sum().toDouble() / arr.size() } - @Suppress("DEPRECATION") - @Test fun indexOfInPrimitiveArrays() { - expect(-1) { byteArrayOf(1, 2, 3).indexOf(0) } - expect(0) { byteArrayOf(1, 2, 3).indexOf(1) } - expect(1) { byteArrayOf(1, 2, 3).indexOf(2) } - expect(2) { byteArrayOf(1, 2, 3).indexOf(3) } - - expect(-1) { shortArrayOf(1, 2, 3).indexOf(0) } - expect(0) { shortArrayOf(1, 2, 3).indexOf(1) } - expect(1) { shortArrayOf(1, 2, 3).indexOf(2) } - expect(2) { shortArrayOf(1, 2, 3).indexOf(3) } - - expect(-1) { intArrayOf(1, 2, 3).indexOf(0) } - expect(0) { intArrayOf(1, 2, 3).indexOf(1) } - expect(1) { intArrayOf(1, 2, 3).indexOf(2) } - expect(2) { intArrayOf(1, 2, 3).indexOf(3) } - - expect(-1) { longArrayOf(1, 2, 3).indexOf(0) } - expect(0) { longArrayOf(1, 2, 3).indexOf(1) } - expect(1) { longArrayOf(1, 2, 3).indexOf(2) } - expect(2) { longArrayOf(1, 2, 3).indexOf(3) } - - expect(-1) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOf(0f) } - expect(0) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOf(1.0f) } - expect(1) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOf(2.0f) } - expect(2) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOf(3.0f) } - - expect(-1) { doubleArrayOf(1.0, 2.0, 3.0).indexOf(0.0) } - expect(0) { doubleArrayOf(1.0, 2.0, 3.0).indexOf(1.0) } - expect(1) { doubleArrayOf(1.0, 2.0, 3.0).indexOf(2.0) } - expect(2) { doubleArrayOf(1.0, 2.0, 3.0).indexOf(3.0) } - - expect(-1) { charArrayOf('a', 'b', 'c').indexOf('z') } - expect(0) { charArrayOf('a', 'b', 'c').indexOf('a') } - expect(1) { charArrayOf('a', 'b', 'c').indexOf('b') } - expect(2) { charArrayOf('a', 'b', 'c').indexOf('c') } - - expect(0) { booleanArrayOf(true, false).indexOf(true) } - expect(1) { booleanArrayOf(true, false).indexOf(false) } - expect(-1) { booleanArrayOf(true).indexOf(false) } - } - - @Test fun indexOf() { - expect(-1) { arrayOf("cat", "dog", "bird").indexOf("mouse") } - expect(0) { arrayOf("cat", "dog", "bird").indexOf("cat") } - expect(1) { arrayOf("cat", "dog", "bird").indexOf("dog") } - expect(2) { arrayOf("cat", "dog", "bird").indexOf("bird") } - expect(0) { arrayOf(null, "dog", null).indexOf(null as String?)} - - expect(-1) { arrayOf("cat", "dog", "bird").indexOfFirst { it.contains("p") } } - expect(0) { arrayOf("cat", "dog", "bird").indexOfFirst { it.startsWith('c') } } - expect(1) { arrayOf("cat", "dog", "bird").indexOfFirst { it.startsWith('d') } } - expect(2) { arrayOf("cat", "dog", "bird").indexOfFirst { it.endsWith('d') } } - - expect(-1) { sequenceOf("cat", "dog", "bird").indexOfFirst { it.contains("p") } } - expect(0) { sequenceOf("cat", "dog", "bird").indexOfFirst { it.startsWith('c') } } - expect(1) { sequenceOf("cat", "dog", "bird").indexOfFirst { it.startsWith('d') } } - expect(2) { sequenceOf("cat", "dog", "bird").indexOfFirst { it.endsWith('d') } } - } - @Test fun lastIndexOf() { expect(-1) { arrayOf("cat", "dog", "bird").lastIndexOf("mouse") } expect(0) { arrayOf("cat", "dog", "bird").lastIndexOf("cat") } @@ -927,84 +806,6 @@ } } - - @Test fun copyRangeInto() { - fun <T> doTest( - copyInto: T.(T, Int, Int, Int) -> T, - assertTEquals: (T, T, String) -> Unit, - toStringT: T.() -> String, - dest: T, newValues: T, - result1: T, result2: T, result3: T - ) { - newValues.copyInto(dest, 0, 1, 3) - assertTypeEquals(result1, dest) - assertTEquals(result1, dest, "Copying from newValues: ${result1.toStringT()}, ${dest.toStringT()}") - - dest.copyInto(dest, 0, 1, 3) - assertTEquals(result2, dest, "Overlapping backward copy: ${result2.toStringT()}, ${dest.toStringT()}") - - dest.copyInto(dest, 1, 0, 2) - assertTEquals(result3, dest, "Overlapping forward copy: ${result2.toStringT()}, ${dest.toStringT()}") - - for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { - val bounds = "start: $start, end: $end" - val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } - assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") - } - for (destIndex in listOf(-1, 2, 4)) { - assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } - } - } - - doTest( - Array<String>::copyInto, { e, a, msg -> assertArrayNotSameButEquals(e, a, msg) }, Array<*>::contentToString, - arrayOf("a", "b", "c"), arrayOf("e", "f", "g"), - arrayOf("f", "g", "c"), arrayOf("g", "c", "c"), arrayOf("g", "g", "c") - ) - - doTest( - IntArray::copyInto, ::assertArrayNotSameButEquals, IntArray::contentToString, - intArrayOf(1, 2, 3), intArrayOf(4, 5, 6), - intArrayOf(5, 6, 3), intArrayOf(6, 3, 3), intArrayOf(6, 6, 3) - ) - - doTest( - LongArray::copyInto, ::assertArrayNotSameButEquals, LongArray::contentToString, - longArrayOf(1, 2, 3), longArrayOf(4, 5, 6), - longArrayOf(5, 6, 3), longArrayOf(6, 3, 3), longArrayOf(6, 6, 3) - ) - - doTest( - ByteArray::copyInto, ::assertArrayNotSameButEquals, ByteArray::contentToString, - byteArrayOf(1, 2, 3), byteArrayOf(4, 5, 6), - byteArrayOf(5, 6, 3), byteArrayOf(6, 3, 3), byteArrayOf(6, 6, 3) - ) - - doTest( - CharArray::copyInto, ::assertArrayNotSameButEquals, CharArray::contentToString, - charArrayOf('a', 'b', 'c'), charArrayOf('e', 'f', 'g'), - charArrayOf('f', 'g', 'c'), charArrayOf('g', 'c', 'c'), charArrayOf('g', 'g', 'c') - ) - - doTest( - UIntArray::copyInto, { e, a, msg -> assertTrue(e contentEquals a, msg) }, UIntArray::contentToString, - uintArrayOf(1, 2, 3), uintArrayOf(4, 5, 6), - uintArrayOf(5, 6, 3), uintArrayOf(6, 3, 3), uintArrayOf(6, 6, 3) - ) - - doTest( - ULongArray::copyInto, { e, a, msg -> assertTrue(e contentEquals a, msg) }, ULongArray::contentToString, - ulongArrayOf(1, 2, 3), ulongArrayOf(4, 5, 6), - ulongArrayOf(5, 6, 3), ulongArrayOf(6, 3, 3), ulongArrayOf(6, 6, 3) - ) - - doTest( - UByteArray::copyInto, { e, a, msg -> assertTrue(e contentEquals a, msg) }, UByteArray::contentToString, - ubyteArrayOf(1, 2, 3), ubyteArrayOf(4, 5, 6), - ubyteArrayOf(5, 6, 3), ubyteArrayOf(6, 3, 3), ubyteArrayOf(6, 6, 3) - ) - } - @Test fun copyRangeIntoVarianceTest() { val sourceArr: Array<out Int> = arrayOf(1, 2, 3) val targetAnyArr: Array<Any?> = arrayOfNulls<Any?>(3) @@ -1449,101 +1250,6 @@ ) } - @Test fun reverseInPlace() { - - fun <TArray, T> doTest(build: Iterable<Int>.() -> TArray, reverse: TArray.() -> Unit, snapshot: TArray.() -> List<T>) { - val arrays = (0..4).map { n -> (1..n).build() } - for (array in arrays) { - val original = array.snapshot() - array.reverse() - val reversed = array.snapshot() - assertEquals(original.asReversed(), reversed) - } - } - - doTest(build = { map {it}.toIntArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toLong()}.toLongArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toByte()}.toByteArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toShort()}.toShortArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toFloat()}.toFloatArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toDouble()}.toDoubleArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {'a' + it}.toCharArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it % 2 == 0}.toBooleanArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toString()}.toTypedArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toString()}.toTypedArray() as Array<out String> }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toUInt()}.toUIntArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toULong()}.toULongArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toUByte()}.toUByteArray() }, reverse = { reverse() }, snapshot = { toList() }) - doTest(build = { map {it.toUShort()}.toUShortArray() }, reverse = { reverse() }, snapshot = { toList() }) - } - - @Test - fun reverseRangeInPlace() { - - fun <TArray, T> doTest( - build: Iterable<Int>.() -> TArray, - reverse: TArray.(fromIndex: Int, toIndex: Int) -> Unit, - snapshot: TArray.() -> List<T> - ) { - val arrays = (0..7).map { n -> n to (0 until n).build() } - for ((size, array) in arrays) { - for (fromIndex in 0 until size) { - for (toIndex in fromIndex..size) { - val original = array.snapshot().toMutableList() - array.reverse(fromIndex, toIndex) - val reversed = array.snapshot() - assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) - } - } - - assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } - assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } - assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } - } - } - - doTest(build = { map {it.toString()}.toTypedArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toString()}.toTypedArray() as Array<out String> }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - - doTest(build = { map {it}.toIntArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toLong()}.toLongArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toByte()}.toByteArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toShort()}.toShortArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toFloat()}.toFloatArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toDouble()}.toDoubleArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {'a' + it}.toCharArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it % 2 == 0}.toBooleanArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toUInt()}.toUIntArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toULong()}.toULongArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toUByte()}.toUByteArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - doTest(build = { map {it.toUShort()}.toUShortArray() }, reverse = { from, to -> reverse(from, to) }, snapshot = { toList() }) - } - - - @Test fun reversed() { - expect(listOf(3, 2, 1)) { intArrayOf(1, 2, 3).reversed() } - expect(listOf<Byte>(3, 2, 1)) { byteArrayOf(1, 2, 3).reversed() } - expect(listOf<Short>(3, 2, 1)) { shortArrayOf(1, 2, 3).reversed() } - expect(listOf<Long>(3, 2, 1)) { longArrayOf(1, 2, 3).reversed() } - expect(listOf(3F, 2F, 1F)) { floatArrayOf(1F, 2F, 3F).reversed() } - expect(listOf(3.0, 2.0, 1.0)) { doubleArrayOf(1.0, 2.0, 3.0).reversed() } - expect(listOf('3', '2', '1')) { charArrayOf('1', '2', '3').reversed() } - expect(listOf(false, false, true)) { booleanArrayOf(true, false, false).reversed() } - expect(listOf("3", "2", "1")) { arrayOf("1", "2", "3").reversed() } - } - - @Test fun reversedArray() { - assertArrayNotSameButEquals(intArrayOf(3, 2, 1), intArrayOf(1, 2, 3).reversedArray()) - assertArrayNotSameButEquals(byteArrayOf(3, 2, 1), byteArrayOf(1, 2, 3).reversedArray()) - assertArrayNotSameButEquals(shortArrayOf(3, 2, 1), shortArrayOf(1, 2, 3).reversedArray()) - assertArrayNotSameButEquals(longArrayOf(3, 2, 1), longArrayOf(1, 2, 3).reversedArray()) - assertArrayNotSameButEquals(floatArrayOf(3F, 2F, 1F), floatArrayOf(1F, 2F, 3F).reversedArray()) - assertArrayNotSameButEquals(doubleArrayOf(3.0, 2.0, 1.0), doubleArrayOf(1.0, 2.0, 3.0).reversedArray()) - assertArrayNotSameButEquals(charArrayOf('3', '2', '1'), charArrayOf('1', '2', '3').reversedArray()) - assertArrayNotSameButEquals(booleanArrayOf(false, false, true), booleanArrayOf(true, false, false).reversedArray()) - assertArrayNotSameButEquals(arrayOf("3", "2", "1"), arrayOf("1", "2", "3").reversedArray()) - assertArrayNotSameButEquals(arrayOf("3", "2", "1"), (arrayOf("1", "2", "3") as Array<out String>).reversedArray()) - } @Test fun onEach() { var count = 0 @@ -1865,33 +1571,6 @@ assertEquals(Array(0, { "" }).asList(), emptyList<String>()) } - @Test fun sort() { - val intArr = intArrayOf(5, 2, 1, 9, 80, Int.MIN_VALUE, Int.MAX_VALUE) - intArr.sort() - assertArrayNotSameButEquals(intArrayOf(Int.MIN_VALUE, 1, 2, 5, 9, 80, Int.MAX_VALUE), intArr) - intArr.sortDescending() - assertArrayNotSameButEquals(intArrayOf(Int.MAX_VALUE, 80, 9, 5, 2, 1, Int.MIN_VALUE), intArr) - - val longArr = longArrayOf(200, 2, 1, 4, 3, Long.MIN_VALUE, Long.MAX_VALUE) - longArr.sort() - assertArrayNotSameButEquals(longArrayOf(Long.MIN_VALUE, 1, 2, 3, 4, 200, Long.MAX_VALUE), longArr) - longArr.sortDescending() - assertArrayNotSameButEquals(longArrayOf(Long.MAX_VALUE, 200, 4, 3, 2, 1, Long.MIN_VALUE), longArr) - - val charArr = charArrayOf('d', 'c', 'E', 'a', '\u0000', '\uFFFF') - charArr.sort() - assertArrayNotSameButEquals(charArrayOf('\u0000', 'E', 'a', 'c', 'd', '\uFFFF'), charArr) - charArr.sortDescending() - assertArrayNotSameButEquals(charArrayOf('\uFFFF', 'd', 'c', 'a', 'E', '\u0000'), charArr) - - - val strArr = arrayOf("9", "80", "all", "Foo") - strArr.sort() - assertArrayNotSameButEquals(arrayOf("80", "9", "Foo", "all"), strArr) - strArr.sortDescending() - assertArrayNotSameButEquals(arrayOf("all", "Foo", "9", "80"), strArr) - } - @Test fun sortRange() { fun <TArray, T : Comparable<T>> doTest( @@ -1977,50 +1656,6 @@ doTest(build = { map {it.toUShort()}.toUShortArray() }, sortDescending = { from, to -> sortDescending(from, to) }, snapshot = { toList() }) } - @Test fun sortedTests() { - assertTrue(arrayOf<Long>().sorted().none()) - assertEquals(listOf(1), arrayOf(1).sorted()) - - fun <A, T: Comparable<T>> arrayData(vararg values: T, toArray: Array<out T>.() -> A) = ArraySortedChecker<A, T>(values.toArray(), naturalOrder()) - - with (arrayData("ac", "aD", "aba") { toList().toTypedArray() }) { - checkSorted<List<String>>({ sorted() }, { sortedDescending() }, { iterator() }) - checkSorted<Array<String>>({ sortedArray() }, { sortedArrayDescending()}, { iterator() } ) - } - - with (arrayData("ac", "aD", "aba") { toList().toTypedArray() as Array<out String> }) { - checkSorted<List<String>>({ sorted() }, { sortedDescending() }, { iterator() }) - checkSorted<Array<out String>>({ sortedArray() }, { sortedArrayDescending()}, { iterator() } ) - } - - with (arrayData(3, 7, 1) { toIntArray() }) { - checkSorted<List<Int>>( { sorted() }, { sortedDescending() }, { iterator() }) - checkSorted<IntArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() }) - } - - - with (arrayData(1L, Long.MIN_VALUE, Long.MAX_VALUE) { toLongArray() }) { - checkSorted<List<Long>>( { sorted() }, { sortedDescending() }, { iterator() }) - checkSorted<LongArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() }) - } - - with (arrayData('a', 'D', 'c') { toCharArray() }) { - checkSorted<List<Char>>( { sorted() }, { sortedDescending() }, { iterator() }) - checkSorted<CharArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() }) - } - - with (arrayData(1.toByte(), Byte.MAX_VALUE, Byte.MIN_VALUE) { toByteArray() }) { - checkSorted<List<Byte>>( { sorted() }, { sortedDescending() }, { iterator() }) - checkSorted<ByteArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() }) - } - - with(arrayData(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, -Double.MAX_VALUE, - 1.0, -1.0, Double.MIN_VALUE, -Double.MIN_VALUE, 0.0, -0.0, Double.NaN) { toDoubleArray() }) { - checkSorted<List<Double>>( { sorted() }, { sortedDescending() }, { iterator() }) - checkSorted<DoubleArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() }) - } - } - @Test fun sortStable() { val keyRange = 'A'..'D' for (size in listOf(10, 100, 2000)) { @@ -2036,25 +1671,6 @@ } } - @Test fun sortByInPlace() { - val data = arrayOf("aa" to 20, "ab" to 3, "aa" to 3) - data.sortBy { it.second } - assertArrayNotSameButEquals(arrayOf("ab" to 3, "aa" to 3, "aa" to 20), data) - - data.sortBy { it.first } - assertArrayNotSameButEquals(arrayOf("aa" to 3, "aa" to 20, "ab" to 3), data) - - data.sortByDescending { (it.first + it.second).length } - assertArrayNotSameButEquals(arrayOf("aa" to 20, "aa" to 3, "ab" to 3), data) - } - - @Test fun sortedBy() { - val values = arrayOf("ac", "aD", "aba") - val indices = values.indices.toList().toIntArray() - - assertEquals(listOf(1, 2, 0), indices.sortedBy { values[it] }) - } - @Test fun sortByStable() { val keyRange = 'A'..'D' for (size in listOf(10, 100, 2000)) { @@ -2082,13 +1698,6 @@ @Test fun sortedWith() { val comparator = compareBy { it: Int -> it % 3 }.thenByDescending { it } - fun <A, T> arrayData(array: A, comparator: Comparator<T>) = ArraySortedChecker<A, T>(array, comparator) - - arrayData(intArrayOf(0, 1, 2, 3, 4, 5), comparator) - .checkSorted<List<Int>>( { sortedWith(comparator) }, { sortedWith(comparator.reversed()) }, { iterator() }) - - arrayData(arrayOf(0, 1, 2, 3, 4, 5), comparator) - .checkSorted<Array<out Int>>( { sortedArrayWith(comparator) }, { sortedArrayWith(comparator.reversed()) }, { iterator() }) // in-place val array = Array(6) { it } @@ -2151,64 +1760,6 @@ } } - private inline fun <T> testShuffle(array: T, shuffle: T.() -> Unit, toList: T.() -> List<*>) { - val original = array.toList() - array.shuffle() - val shuffled = array.toList() - assertNotEquals(original, shuffled) - assertEquals(original.groupBy { it }, shuffled.groupBy { it }) - } - - @Test - fun shuffle() { - val numbers = List(100) { it } - testShuffle(numbers.map(Int::toInt).toIntArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map(Int::toLong).toLongArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map(Int::toByte).toByteArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map(Int::toShort).toShortArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map(Int::toFloat).toFloatArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map(Int::toDouble).toDoubleArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map(Int::toChar).toCharArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map { it % 2 == 0 }.toBooleanArray(), { shuffle() }, { toList() }) - - testShuffle(numbers.map(Int::toUInt).toUIntArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map(Int::toULong).toULongArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map(Int::toUByte).toUByteArray(), { shuffle() }, { toList() }) - testShuffle(numbers.map(Int::toUShort).toUShortArray(), { shuffle() }, { toList() }) - - testShuffle(arrayOf(1, "x", null, Any(), 'a', 2u, 5.0), { shuffle() }, { toList() }) - } - - private inline fun <T> testShuffleR(array: T, shuffle: T.(Random) -> Unit, toList: T.() -> List<*>) { - val seed = Random.nextInt() - val original = array.toList() - val originalShuffled = original.shuffled(Random(seed)) - array.shuffle(Random(seed)) - val shuffled = array.toList() - assertNotEquals(original, shuffled) - assertEquals(originalShuffled, shuffled) - } - - @Test - fun shufflePredictably() { - val numbers = List(16) { it } - testShuffleR(numbers.map(Int::toInt).toIntArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map(Int::toLong).toLongArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map(Int::toByte).toByteArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map(Int::toShort).toShortArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map(Int::toFloat).toFloatArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map(Int::toDouble).toDoubleArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map(Int::toChar).toCharArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map { it % 2 == 0 }.toBooleanArray(), { r -> shuffle(r) }, { toList() }) - - testShuffleR(numbers.map(Int::toUInt).toUIntArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map(Int::toULong).toULongArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map(Int::toUByte).toUByteArray(), { r -> shuffle(r) }, { toList() }) - testShuffleR(numbers.map(Int::toUShort).toUShortArray(), { r -> shuffle(r) }, { toList() }) - - testShuffleR(arrayOf(1, "x", null, Any(), 'a', 2u, 5.0), { r -> shuffle(r) }, { toList() }) - } - @Test fun elementAt() { expect(0) { byteArrayOf(0, 1, 2).elementAt(0) } @@ -2299,7 +1850,7 @@ fun <K : Comparable<K>> Array<out Sortable<K>>.assertStableSorted(descending: Boolean = false) = iterator().assertStableSorted(descending = descending) -private class ArraySortedChecker<A, T>(val array: A, val comparator: Comparator<in T>) { +internal class ArraySortedChecker<A, T>(val array: A, val comparator: Comparator<in T>) { public fun <R> checkSorted(sorted: A.() -> R, sortedDescending: A.() -> R, iterator: R.() -> Iterator<T>) { array.sorted().iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } array.sortedDescending().iterator().assertSorted { a, b -> comparator.compare(a, b) >= 0 }
diff --git a/libraries/stdlib/test/collections/CollectionTest.kt b/libraries/stdlib/test/collections/CollectionTest.kt index 3467bcf..29bd499 100644 --- a/libraries/stdlib/test/collections/CollectionTest.kt +++ b/libraries/stdlib/test/collections/CollectionTest.kt
@@ -152,23 +152,6 @@ assertEquals(0, charValues.size) } - @Test fun foldIndexed() { - expect(42) { - val numbers = listOf(1, 2, 3, 4) - numbers.foldIndexed(0) { index, a, b -> index * (a + b) } - } - - expect(0) { - val numbers = arrayListOf<Int>() - numbers.foldIndexed(0) { index, a, b -> index * (a + b) } - } - - expect("11234") { - val numbers = listOf(1, 2, 3, 4) - numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } - } - } - @Test fun foldIndexedWithDifferentTypes() { expect(10) { val numbers = listOf("a", "ab", "abc") @@ -188,13 +171,6 @@ } } - @Test fun foldRightIndexed() { - expect("12343210") { - val numbers = listOf(1, 2, 3, 4) - numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } - } - } - @Test fun foldRightIndexedWithDifferentTypes() { expect("12343210") { val numbers = listOf(1, 2, 3, 4) @@ -851,40 +827,6 @@ assertIsPositiveZero(listOf(0.0F, -0.0F).shuffled().maxOrNull()!!.toDouble()) } - @Test fun minWithOrNull() { - expect(null, { listOf<Int>().minWithOrNull(naturalOrder()) }) - expect(1, { listOf(1).minWithOrNull(naturalOrder()) }) - expect("a", { listOf("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER) }) - expect("a", { listOf("a", "B").asSequence().minWithOrNull(STRING_CASE_INSENSITIVE_ORDER) }) - } - - @Test fun maxWithOrNull() { - expect(null, { listOf<Int>().maxWithOrNull(naturalOrder()) }) - expect(1, { listOf(1).maxWithOrNull(naturalOrder()) }) - expect("B", { listOf("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER) }) - expect("B", { listOf("a", "B").asSequence().maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER) }) - } - - @Test fun minByOrNull() { - expect(null, { listOf<Int>().minByOrNull { it } }) - expect(1, { listOf(1).minByOrNull { it } }) - expect(3, { listOf(2, 3).minByOrNull { -it } }) - expect('a', { listOf('a', 'b').minByOrNull { "x$it" } }) - expect("b", { listOf("b", "abc").minByOrNull { it.length } }) - expect(null, { listOf<Int>().asSequence().minByOrNull { it } }) - expect(3, { listOf(2, 3).asSequence().minByOrNull { -it } }) - } - - @Test fun maxByOrNull() { - expect(null, { listOf<Int>().maxByOrNull { it } }) - expect(1, { listOf(1).maxByOrNull { it } }) - expect(2, { listOf(2, 3).maxByOrNull { -it } }) - expect('b', { listOf('a', 'b').maxByOrNull { "x$it" } }) - expect("abc", { listOf("b", "abc").maxByOrNull { it.length } }) - expect(null, { listOf<Int>().asSequence().maxByOrNull { it } }) - expect(2, { listOf(2, 3).asSequence().maxByOrNull { -it } }) - } - @Test fun minByOrNullEvaluateOnce() { var c = 0 expect(1, { listOf(5, 4, 3, 2, 1).minByOrNull { c++; it * it } }) @@ -1037,18 +979,6 @@ -0.0, -Double.MIN_VALUE, -1.0, -Double.MAX_VALUE, Double.NEGATIVE_INFINITY), dataDouble.sortedDescending()) } - @Test fun sortByInPlace() { - val data = arrayListOf("aa" to 20, "ab" to 3, "aa" to 3) - data.sortBy { it.second } - assertEquals(listOf("ab" to 3, "aa" to 3, "aa" to 20), data) - - data.sortBy { it.first } - assertEquals(listOf("aa" to 3, "aa" to 20, "ab" to 3), data) - - data.sortByDescending { (it.first + it.second).length } - assertEquals(listOf("aa" to 20, "aa" to 3, "ab" to 3), data) - } - @Test fun sortStable() { val keyRange = 'A'..'D' for (size in listOf(10, 100, 2000)) { @@ -1064,12 +994,6 @@ } } - @Test fun sortedBy() { - assertEquals(listOf("two" to 3, "three" to 20), listOf("three" to 20, "two" to 3).sortedBy { it.second }) - assertEquals(listOf("three" to 20, "two" to 3), listOf("three" to 20, "two" to 3).sortedBy { it.first }) - assertEquals(listOf("three", "two"), listOf("two", "three").sortedByDescending { it.length }) - } - @Test fun sortedNullableBy() { fun String.nullIfEmpty() = if (isEmpty()) null else this listOf(null, "", "a").let { @@ -1088,15 +1012,6 @@ } } - @Test fun sortedWith() { - val comparator = compareBy<String> { it.toUpperCase().reversed() } - val data = listOf("cat", "dad", "BAD") - - expect(listOf("BAD", "dad", "cat")) { data.sortedWith(comparator) } - expect(listOf("cat", "dad", "BAD")) { data.sortedWith(comparator.reversed()) } - expect(listOf("BAD", "dad", "cat")) { data.sortedWith(comparator.reversed().reversed()) } - } - @Test fun sortByStable() { val keyRange = 'A'..'D' for (size in listOf(10, 100, 2000)) {
diff --git a/libraries/stdlib/test/collections/UnsignedArraysTest.kt b/libraries/stdlib/test/collections/UnsignedArraysTest.kt index e8d8216..792b54f 100644 --- a/libraries/stdlib/test/collections/UnsignedArraysTest.kt +++ b/libraries/stdlib/test/collections/UnsignedArraysTest.kt
@@ -248,22 +248,6 @@ } @Test - fun indexOf() { - expect(-1) { ubyteArrayOf(1, 2, 3).indexOf(0) } - expect(0) { ushortArrayOf(1, 2, 3).indexOf(1) } - expect(1) { uintArrayOf(1, 2, 3).indexOf(2) } - expect(2) { ulongArrayOf(1, 2, 3).indexOf(3) } - } - - @Test - fun indexOfFirst() { - expect(-1) { ubyteArrayOf(1, 2, 3).indexOfFirst { it == 5.toUByte() } } - expect(0) { ushortArrayOf(1, 2, 3).indexOfFirst { it % 2u == 1u } } - expect(1) { uintArrayOf(1, 2, 3).indexOfFirst { it % 2u == 0u } } - expect(2) { ulongArrayOf(1, 2, 3).indexOfFirst { it == 3.toULong() } } - } - - @Test fun lastIndexOf() { expect(-1) { ubyteArrayOf(1, 2, 3).lastIndexOf(0) } expect(0) { ushortArrayOf(1, 2, 3).lastIndexOf(1) }
diff --git a/libraries/stdlib/test/generated/_ArraysTest.kt b/libraries/stdlib/test/generated/_ArraysTest.kt new file mode 100644 index 0000000..203e394 --- /dev/null +++ b/libraries/stdlib/test/generated/_ArraysTest.kt
@@ -0,0 +1,1947 @@ +/* + * 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 + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLibTests.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import test.comparisons.STRING_CASE_INSENSITIVE_ORDER +import kotlin.random.* +import test.assertArrayContentEquals +import kotlin.test.* + +class _ArraysTest { + @Test + fun foldIndexed_Array() { + expect(8) { arrayOf<Int>(1, 2, 3).foldIndexed(0) { i, acc, e -> acc + i.toInt() * e } } + expect(10) { arrayOf<Int>(1, 2, 3).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15) { arrayOf<Int>(1, 2, 3).foldIndexed(1) { i, acc, e -> acc * (i.toInt() + e) } } + expect(" 0-1 1-2 2-3") { arrayOf<Int>(1, 2, 3).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42) { + val numbers = arrayOf<Int>(1, 2, 3, 4) + numbers.foldIndexed(0) { index, a, b -> index.toInt() * (a + b) } + } + expect(0) { + val numbers = arrayOf<Int>() + numbers.foldIndexed(0) { index, a, b -> index.toInt() * (a + b) } + } + expect("11234") { + val numbers = arrayOf<Int>(1, 2, 3, 4) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldIndexed_ByteArray() { + expect(8) { byteArrayOf(1, 2, 3).foldIndexed(0) { i, acc, e -> acc + i.toByte() * e } } + expect(10) { byteArrayOf(1, 2, 3).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15) { byteArrayOf(1, 2, 3).foldIndexed(1) { i, acc, e -> acc * (i.toByte() + e) } } + expect(" 0-1 1-2 2-3") { byteArrayOf(1, 2, 3).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42) { + val numbers = byteArrayOf(1, 2, 3, 4) + numbers.foldIndexed(0) { index, a, b -> index.toByte() * (a + b) } + } + expect(0) { + val numbers = byteArrayOf() + numbers.foldIndexed(0) { index, a, b -> index.toByte() * (a + b) } + } + expect("11234") { + val numbers = byteArrayOf(1, 2, 3, 4) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldIndexed_ShortArray() { + expect(8) { shortArrayOf(1, 2, 3).foldIndexed(0) { i, acc, e -> acc + i.toShort() * e } } + expect(10) { shortArrayOf(1, 2, 3).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15) { shortArrayOf(1, 2, 3).foldIndexed(1) { i, acc, e -> acc * (i.toShort() + e) } } + expect(" 0-1 1-2 2-3") { shortArrayOf(1, 2, 3).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42) { + val numbers = shortArrayOf(1, 2, 3, 4) + numbers.foldIndexed(0) { index, a, b -> index.toShort() * (a + b) } + } + expect(0) { + val numbers = shortArrayOf() + numbers.foldIndexed(0) { index, a, b -> index.toShort() * (a + b) } + } + expect("11234") { + val numbers = shortArrayOf(1, 2, 3, 4) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldIndexed_IntArray() { + expect(8) { intArrayOf(1, 2, 3).foldIndexed(0) { i, acc, e -> acc + i.toInt() * e } } + expect(10) { intArrayOf(1, 2, 3).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15) { intArrayOf(1, 2, 3).foldIndexed(1) { i, acc, e -> acc * (i.toInt() + e) } } + expect(" 0-1 1-2 2-3") { intArrayOf(1, 2, 3).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42) { + val numbers = intArrayOf(1, 2, 3, 4) + numbers.foldIndexed(0) { index, a, b -> index.toInt() * (a + b) } + } + expect(0) { + val numbers = intArrayOf() + numbers.foldIndexed(0) { index, a, b -> index.toInt() * (a + b) } + } + expect("11234") { + val numbers = intArrayOf(1, 2, 3, 4) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldIndexed_LongArray() { + expect(8L) { longArrayOf(1L, 2L, 3L).foldIndexed(0L) { i, acc, e -> acc + i.toLong() * e } } + expect(10) { longArrayOf(1L, 2L, 3L).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15L) { longArrayOf(1L, 2L, 3L).foldIndexed(1L) { i, acc, e -> acc * (i.toLong() + e) } } + expect(" 0-1 1-2 2-3") { longArrayOf(1L, 2L, 3L).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42L) { + val numbers = longArrayOf(1L, 2L, 3L, 4L) + numbers.foldIndexed(0L) { index, a, b -> index.toLong() * (a + b) } + } + expect(0L) { + val numbers = longArrayOf() + numbers.foldIndexed(0L) { index, a, b -> index.toLong() * (a + b) } + } + expect("11234") { + val numbers = longArrayOf(1L, 2L, 3L, 4L) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldIndexed_FloatArray() { + expect(8.0f) { floatArrayOf(1.0f, 2.0f, 3.0f).foldIndexed(0.0f) { i, acc, e -> acc + i.toFloat() * e } } + expect(10) { floatArrayOf(1.0f, 2.0f, 3.0f).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15.0f) { floatArrayOf(1.0f, 2.0f, 3.0f).foldIndexed(1.0f) { i, acc, e -> acc * (i.toFloat() + e) } } + expect(" 0-1.0 1-2.0 2-3.0") { floatArrayOf(1.0f, 2.0f, 3.0f).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42.0f) { + val numbers = floatArrayOf(1.0f, 2.0f, 3.0f, 4.0f) + numbers.foldIndexed(0.0f) { index, a, b -> index.toFloat() * (a + b) } + } + expect(0.0f) { + val numbers = floatArrayOf() + numbers.foldIndexed(0.0f) { index, a, b -> index.toFloat() * (a + b) } + } + expect("1.01.02.03.04.0") { + val numbers = floatArrayOf(1.0f, 2.0f, 3.0f, 4.0f) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldIndexed_DoubleArray() { + expect(8.0) { doubleArrayOf(1.0, 2.0, 3.0).foldIndexed(0.0) { i, acc, e -> acc + i.toDouble() * e } } + expect(10) { doubleArrayOf(1.0, 2.0, 3.0).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15.0) { doubleArrayOf(1.0, 2.0, 3.0).foldIndexed(1.0) { i, acc, e -> acc * (i.toDouble() + e) } } + expect(" 0-1.0 1-2.0 2-3.0") { doubleArrayOf(1.0, 2.0, 3.0).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42.0) { + val numbers = doubleArrayOf(1.0, 2.0, 3.0, 4.0) + numbers.foldIndexed(0.0) { index, a, b -> index.toDouble() * (a + b) } + } + expect(0.0) { + val numbers = doubleArrayOf() + numbers.foldIndexed(0.0) { index, a, b -> index.toDouble() * (a + b) } + } + expect("1.01.02.03.04.0") { + val numbers = doubleArrayOf(1.0, 2.0, 3.0, 4.0) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldRightIndexed_Array() { + expect(8) { arrayOf<Int>(1, 2, 3).foldRightIndexed(0) { i, e, acc -> acc + i.toInt() * e } } + expect(10) { arrayOf<Int>(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15) { arrayOf<Int>(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc * (i.toInt() + e) } } + expect(" 2-3 1-2 0-1") { arrayOf<Int>(1, 2, 3).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = arrayOf<Int>(1, 2, 3, 4) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun foldRightIndexed_ByteArray() { + expect(8) { byteArrayOf(1, 2, 3).foldRightIndexed(0) { i, e, acc -> acc + i.toByte() * e } } + expect(10) { byteArrayOf(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15) { byteArrayOf(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc * (i.toByte() + e) } } + expect(" 2-3 1-2 0-1") { byteArrayOf(1, 2, 3).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = byteArrayOf(1, 2, 3, 4) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun foldRightIndexed_ShortArray() { + expect(8) { shortArrayOf(1, 2, 3).foldRightIndexed(0) { i, e, acc -> acc + i.toShort() * e } } + expect(10) { shortArrayOf(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15) { shortArrayOf(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc * (i.toShort() + e) } } + expect(" 2-3 1-2 0-1") { shortArrayOf(1, 2, 3).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = shortArrayOf(1, 2, 3, 4) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun foldRightIndexed_IntArray() { + expect(8) { intArrayOf(1, 2, 3).foldRightIndexed(0) { i, e, acc -> acc + i.toInt() * e } } + expect(10) { intArrayOf(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15) { intArrayOf(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc * (i.toInt() + e) } } + expect(" 2-3 1-2 0-1") { intArrayOf(1, 2, 3).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = intArrayOf(1, 2, 3, 4) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun foldRightIndexed_LongArray() { + expect(8L) { longArrayOf(1L, 2L, 3L).foldRightIndexed(0L) { i, e, acc -> acc + i.toLong() * e } } + expect(10) { longArrayOf(1L, 2L, 3L).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15L) { longArrayOf(1L, 2L, 3L).foldRightIndexed(1L) { i, e, acc -> acc * (i.toLong() + e) } } + expect(" 2-3 1-2 0-1") { longArrayOf(1L, 2L, 3L).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = longArrayOf(1L, 2L, 3L, 4L) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun foldRightIndexed_FloatArray() { + expect(8.0f) { floatArrayOf(1.0f, 2.0f, 3.0f).foldRightIndexed(0.0f) { i, e, acc -> acc + i.toFloat() * e } } + expect(10) { floatArrayOf(1.0f, 2.0f, 3.0f).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15.0f) { floatArrayOf(1.0f, 2.0f, 3.0f).foldRightIndexed(1.0f) { i, e, acc -> acc * (i.toFloat() + e) } } + expect(" 2-3.0 1-2.0 0-1.0") { floatArrayOf(1.0f, 2.0f, 3.0f).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("1.02.03.04.03210") { + val numbers = floatArrayOf(1.0f, 2.0f, 3.0f, 4.0f) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun foldRightIndexed_DoubleArray() { + expect(8.0) { doubleArrayOf(1.0, 2.0, 3.0).foldRightIndexed(0.0) { i, e, acc -> acc + i.toDouble() * e } } + expect(10) { doubleArrayOf(1.0, 2.0, 3.0).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15.0) { doubleArrayOf(1.0, 2.0, 3.0).foldRightIndexed(1.0) { i, e, acc -> acc * (i.toDouble() + e) } } + expect(" 2-3.0 1-2.0 0-1.0") { doubleArrayOf(1.0, 2.0, 3.0).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("1.02.03.04.03210") { + val numbers = doubleArrayOf(1.0, 2.0, 3.0, 4.0) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun maxByOrNull_Array() { + assertEquals(null, arrayOf<Int>().maxByOrNull { it }) + assertEquals(1, arrayOf<Int>(1).maxByOrNull { it }) + assertEquals(3, arrayOf<Int>(3, 2).maxByOrNull { it * it }) + assertEquals(3, arrayOf<Int>(3, 2).maxByOrNull { "a" }) + assertEquals(3, arrayOf<Int>(3, 2).maxByOrNull { it.toString() }) + assertEquals(2, arrayOf<Int>(2, 3).maxByOrNull { -it }) + assertEquals('b', arrayOf('a', 'b').maxByOrNull { "x$it" }) + assertEquals("abc", arrayOf("b", "abc").maxByOrNull { it.length }) + } + + @Test + fun maxByOrNull_ByteArray() { + assertEquals(null, byteArrayOf().maxByOrNull { it }) + assertEquals(1, byteArrayOf(1).maxByOrNull { it }) + assertEquals(3, byteArrayOf(3, 2).maxByOrNull { it * it }) + assertEquals(3, byteArrayOf(3, 2).maxByOrNull { "a" }) + assertEquals(3, byteArrayOf(3, 2).maxByOrNull { it.toString() }) + assertEquals(2, byteArrayOf(2, 3).maxByOrNull { -it }) + } + + @Test + fun maxByOrNull_ShortArray() { + assertEquals(null, shortArrayOf().maxByOrNull { it }) + assertEquals(1, shortArrayOf(1).maxByOrNull { it }) + assertEquals(3, shortArrayOf(3, 2).maxByOrNull { it * it }) + assertEquals(3, shortArrayOf(3, 2).maxByOrNull { "a" }) + assertEquals(3, shortArrayOf(3, 2).maxByOrNull { it.toString() }) + assertEquals(2, shortArrayOf(2, 3).maxByOrNull { -it }) + } + + @Test + fun maxByOrNull_IntArray() { + assertEquals(null, intArrayOf().maxByOrNull { it }) + assertEquals(1, intArrayOf(1).maxByOrNull { it }) + assertEquals(3, intArrayOf(3, 2).maxByOrNull { it * it }) + assertEquals(3, intArrayOf(3, 2).maxByOrNull { "a" }) + assertEquals(3, intArrayOf(3, 2).maxByOrNull { it.toString() }) + assertEquals(2, intArrayOf(2, 3).maxByOrNull { -it }) + } + + @Test + fun maxByOrNull_LongArray() { + assertEquals(null, longArrayOf().maxByOrNull { it }) + assertEquals(1L, longArrayOf(1L).maxByOrNull { it }) + assertEquals(3L, longArrayOf(3L, 2L).maxByOrNull { it * it }) + assertEquals(3L, longArrayOf(3L, 2L).maxByOrNull { "a" }) + assertEquals(3L, longArrayOf(3L, 2L).maxByOrNull { it.toString() }) + assertEquals(2L, longArrayOf(2L, 3L).maxByOrNull { -it }) + assertEquals(3000000000000, longArrayOf(3000000000000, 2000000000000).maxByOrNull { it + 1 }) + } + + @Test + fun maxByOrNull_FloatArray() { + assertEquals(null, floatArrayOf().maxByOrNull { it }) + assertEquals(1.0f, floatArrayOf(1.0f).maxByOrNull { it }) + assertEquals(3.0f, floatArrayOf(3.0f, 2.0f).maxByOrNull { it * it }) + assertEquals(3.0f, floatArrayOf(3.0f, 2.0f).maxByOrNull { "a" }) + assertEquals(3.0f, floatArrayOf(3.0f, 2.0f).maxByOrNull { it.toString() }) + assertEquals(2.0f, floatArrayOf(2.0f, 3.0f).maxByOrNull { -it }) + } + + @Test + fun maxByOrNull_DoubleArray() { + assertEquals(null, doubleArrayOf().maxByOrNull { it }) + assertEquals(1.0, doubleArrayOf(1.0).maxByOrNull { it }) + assertEquals(3.0, doubleArrayOf(3.0, 2.0).maxByOrNull { it * it }) + assertEquals(3.0, doubleArrayOf(3.0, 2.0).maxByOrNull { "a" }) + assertEquals(3.0, doubleArrayOf(3.0, 2.0).maxByOrNull { it.toString() }) + assertEquals(2.0, doubleArrayOf(2.0, 3.0).maxByOrNull { -it }) + } + + @Test + fun maxByOrNull_BooleanArray() { + assertEquals(true, booleanArrayOf(true, false).maxByOrNull { it.toString() }) + assertEquals(false, booleanArrayOf(true, false).maxByOrNull { it.toString().length }) + } + + @Test + fun maxByOrNull_CharArray() { + assertEquals('b', charArrayOf('a', 'b').maxByOrNull { "x$it" }) + assertEquals('b', charArrayOf('b', 'a').maxByOrNull { "$it".length }) + } + + @Test + fun maxWithOrNull_Array() { + assertEquals(null, arrayOf<Int>().maxWithOrNull(naturalOrder())) + assertEquals(1, arrayOf<Int>(1).maxWithOrNull(naturalOrder())) + assertEquals(3, arrayOf<Int>(2, 3, 4).maxWithOrNull(compareBy { it % 4 })) + assertEquals("B", arrayOf("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) + } + + @Test + fun maxWithOrNull_ByteArray() { + assertEquals(null, byteArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1, byteArrayOf(1).maxWithOrNull(naturalOrder())) + assertEquals(3, byteArrayOf(2, 3, 4).maxWithOrNull(compareBy { it % 4 })) + } + + @Test + fun maxWithOrNull_ShortArray() { + assertEquals(null, shortArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1, shortArrayOf(1).maxWithOrNull(naturalOrder())) + assertEquals(3, shortArrayOf(2, 3, 4).maxWithOrNull(compareBy { it % 4 })) + } + + @Test + fun maxWithOrNull_IntArray() { + assertEquals(null, intArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1, intArrayOf(1).maxWithOrNull(naturalOrder())) + assertEquals(3, intArrayOf(2, 3, 4).maxWithOrNull(compareBy { it % 4 })) + } + + @Test + fun maxWithOrNull_LongArray() { + assertEquals(null, longArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1L, longArrayOf(1L).maxWithOrNull(naturalOrder())) + assertEquals(3L, longArrayOf(2L, 3L, 4L).maxWithOrNull(compareBy { it % 4L })) + } + + @Test + fun maxWithOrNull_FloatArray() { + assertEquals(null, floatArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1.0f, floatArrayOf(1.0f).maxWithOrNull(naturalOrder())) + assertEquals(3.0f, floatArrayOf(2.0f, 3.0f, 4.0f).maxWithOrNull(compareBy { it % 4.0f })) + } + + @Test + fun maxWithOrNull_DoubleArray() { + assertEquals(null, doubleArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1.0, doubleArrayOf(1.0).maxWithOrNull(naturalOrder())) + assertEquals(3.0, doubleArrayOf(2.0, 3.0, 4.0).maxWithOrNull(compareBy { it % 4.0 })) + } + + @Test + fun minByOrNull_Array() { + assertEquals(null, arrayOf<Int>().minByOrNull { it }) + assertEquals(1, arrayOf<Int>(1).minByOrNull { it }) + assertEquals(2, arrayOf<Int>(3, 2).minByOrNull { it * it }) + assertEquals(3, arrayOf<Int>(3, 2).minByOrNull { "a" }) + assertEquals(2, arrayOf<Int>(3, 2).minByOrNull { it.toString() }) + assertEquals(3, arrayOf<Int>(2, 3).minByOrNull { -it }) + assertEquals('a', arrayOf('a', 'b').minByOrNull { "x$it" }) + assertEquals("b", arrayOf("b", "abc").minByOrNull { it.length }) + } + + @Test + fun minByOrNull_ByteArray() { + assertEquals(null, byteArrayOf().minByOrNull { it }) + assertEquals(1, byteArrayOf(1).minByOrNull { it }) + assertEquals(2, byteArrayOf(3, 2).minByOrNull { it * it }) + assertEquals(3, byteArrayOf(3, 2).minByOrNull { "a" }) + assertEquals(2, byteArrayOf(3, 2).minByOrNull { it.toString() }) + assertEquals(3, byteArrayOf(2, 3).minByOrNull { -it }) + } + + @Test + fun minByOrNull_ShortArray() { + assertEquals(null, shortArrayOf().minByOrNull { it }) + assertEquals(1, shortArrayOf(1).minByOrNull { it }) + assertEquals(2, shortArrayOf(3, 2).minByOrNull { it * it }) + assertEquals(3, shortArrayOf(3, 2).minByOrNull { "a" }) + assertEquals(2, shortArrayOf(3, 2).minByOrNull { it.toString() }) + assertEquals(3, shortArrayOf(2, 3).minByOrNull { -it }) + } + + @Test + fun minByOrNull_IntArray() { + assertEquals(null, intArrayOf().minByOrNull { it }) + assertEquals(1, intArrayOf(1).minByOrNull { it }) + assertEquals(2, intArrayOf(3, 2).minByOrNull { it * it }) + assertEquals(3, intArrayOf(3, 2).minByOrNull { "a" }) + assertEquals(2, intArrayOf(3, 2).minByOrNull { it.toString() }) + assertEquals(3, intArrayOf(2, 3).minByOrNull { -it }) + } + + @Test + fun minByOrNull_LongArray() { + assertEquals(null, longArrayOf().minByOrNull { it }) + assertEquals(1L, longArrayOf(1L).minByOrNull { it }) + assertEquals(2L, longArrayOf(3L, 2L).minByOrNull { it * it }) + assertEquals(3L, longArrayOf(3L, 2L).minByOrNull { "a" }) + assertEquals(2L, longArrayOf(3L, 2L).minByOrNull { it.toString() }) + assertEquals(3L, longArrayOf(2L, 3L).minByOrNull { -it }) + assertEquals(2000000000000, longArrayOf(3000000000000, 2000000000000).minByOrNull { it + 1 }) + } + + @Test + fun minByOrNull_FloatArray() { + assertEquals(null, floatArrayOf().minByOrNull { it }) + assertEquals(1.0f, floatArrayOf(1.0f).minByOrNull { it }) + assertEquals(2.0f, floatArrayOf(3.0f, 2.0f).minByOrNull { it * it }) + assertEquals(3.0f, floatArrayOf(3.0f, 2.0f).minByOrNull { "a" }) + assertEquals(2.0f, floatArrayOf(3.0f, 2.0f).minByOrNull { it.toString() }) + assertEquals(3.0f, floatArrayOf(2.0f, 3.0f).minByOrNull { -it }) + } + + @Test + fun minByOrNull_DoubleArray() { + assertEquals(null, doubleArrayOf().minByOrNull { it }) + assertEquals(1.0, doubleArrayOf(1.0).minByOrNull { it }) + assertEquals(2.0, doubleArrayOf(3.0, 2.0).minByOrNull { it * it }) + assertEquals(3.0, doubleArrayOf(3.0, 2.0).minByOrNull { "a" }) + assertEquals(2.0, doubleArrayOf(3.0, 2.0).minByOrNull { it.toString() }) + assertEquals(3.0, doubleArrayOf(2.0, 3.0).minByOrNull { -it }) + } + + @Test + fun minByOrNull_BooleanArray() { + assertEquals(false, booleanArrayOf(true, false).minByOrNull { it.toString() }) + assertEquals(true, booleanArrayOf(true, false).minByOrNull { it.toString().length }) + } + + @Test + fun minByOrNull_CharArray() { + assertEquals('a', charArrayOf('a', 'b').minByOrNull { "x$it" }) + assertEquals('b', charArrayOf('b', 'a').minByOrNull { "$it".length }) + } + + @Test + fun minWithOrNull_Array() { + assertEquals(null, arrayOf<Int>().minWithOrNull(naturalOrder())) + assertEquals(1, arrayOf<Int>(1).minWithOrNull(naturalOrder())) + assertEquals(4, arrayOf<Int>(2, 3, 4).minWithOrNull(compareBy { it % 4 })) + assertEquals("a", arrayOf("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) + } + + @Test + fun minWithOrNull_ByteArray() { + assertEquals(null, byteArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1, byteArrayOf(1).minWithOrNull(naturalOrder())) + assertEquals(4, byteArrayOf(2, 3, 4).minWithOrNull(compareBy { it % 4 })) + } + + @Test + fun minWithOrNull_ShortArray() { + assertEquals(null, shortArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1, shortArrayOf(1).minWithOrNull(naturalOrder())) + assertEquals(4, shortArrayOf(2, 3, 4).minWithOrNull(compareBy { it % 4 })) + } + + @Test + fun minWithOrNull_IntArray() { + assertEquals(null, intArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1, intArrayOf(1).minWithOrNull(naturalOrder())) + assertEquals(4, intArrayOf(2, 3, 4).minWithOrNull(compareBy { it % 4 })) + } + + @Test + fun minWithOrNull_LongArray() { + assertEquals(null, longArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1L, longArrayOf(1L).minWithOrNull(naturalOrder())) + assertEquals(4L, longArrayOf(2L, 3L, 4L).minWithOrNull(compareBy { it % 4L })) + } + + @Test + fun minWithOrNull_FloatArray() { + assertEquals(null, floatArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1.0f, floatArrayOf(1.0f).minWithOrNull(naturalOrder())) + assertEquals(4.0f, floatArrayOf(2.0f, 3.0f, 4.0f).minWithOrNull(compareBy { it % 4.0f })) + } + + @Test + fun minWithOrNull_DoubleArray() { + assertEquals(null, doubleArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1.0, doubleArrayOf(1.0).minWithOrNull(naturalOrder())) + assertEquals(4.0, doubleArrayOf(2.0, 3.0, 4.0).minWithOrNull(compareBy { it % 4.0 })) + } + + @Test + fun indexOf_Array() { + expect(-1) { arrayOf<Int>(1, 2, 3).indexOf(0) } + expect(0) { arrayOf<Int>(1, 2, 3).indexOf(1) } + expect(1) { arrayOf<Int>(1, 2, 3).indexOf(2) } + expect(2) { arrayOf<Int>(1, 2, 3).indexOf(3) } + expect(-1) { arrayOf("cat", "dog", "bird").indexOf("mouse") } + expect(0) { arrayOf("cat", "dog", "bird").indexOf("cat") } + expect(1) { arrayOf("cat", "dog", "bird").indexOf("dog") } + expect(2) { arrayOf("cat", "dog", "bird").indexOf("bird") } + expect(0) { arrayOf(null, "dog", null).indexOf(null as String?)} + } + + @Test + fun indexOf_ByteArray() { + expect(-1) { byteArrayOf(1, 2, 3).indexOf(0) } + expect(0) { byteArrayOf(1, 2, 3).indexOf(1) } + expect(1) { byteArrayOf(1, 2, 3).indexOf(2) } + expect(2) { byteArrayOf(1, 2, 3).indexOf(3) } + } + + @Test + fun indexOf_ShortArray() { + expect(-1) { shortArrayOf(1, 2, 3).indexOf(0) } + expect(0) { shortArrayOf(1, 2, 3).indexOf(1) } + expect(1) { shortArrayOf(1, 2, 3).indexOf(2) } + expect(2) { shortArrayOf(1, 2, 3).indexOf(3) } + } + + @Test + fun indexOf_IntArray() { + expect(-1) { intArrayOf(1, 2, 3).indexOf(0) } + expect(0) { intArrayOf(1, 2, 3).indexOf(1) } + expect(1) { intArrayOf(1, 2, 3).indexOf(2) } + expect(2) { intArrayOf(1, 2, 3).indexOf(3) } + } + + @Test + fun indexOf_LongArray() { + expect(-1) { longArrayOf(1L, 2L, 3L).indexOf(0L) } + expect(0) { longArrayOf(1L, 2L, 3L).indexOf(1L) } + expect(1) { longArrayOf(1L, 2L, 3L).indexOf(2L) } + expect(2) { longArrayOf(1L, 2L, 3L).indexOf(3L) } + } + + @Suppress("DEPRECATION") + @Test + fun indexOf_FloatArray() { + expect(-1) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOf(0.0f) } + expect(0) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOf(1.0f) } + expect(1) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOf(2.0f) } + expect(2) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOf(3.0f) } + } + + @Suppress("DEPRECATION") + @Test + fun indexOf_DoubleArray() { + expect(-1) { doubleArrayOf(1.0, 2.0, 3.0).indexOf(0.0) } + expect(0) { doubleArrayOf(1.0, 2.0, 3.0).indexOf(1.0) } + expect(1) { doubleArrayOf(1.0, 2.0, 3.0).indexOf(2.0) } + expect(2) { doubleArrayOf(1.0, 2.0, 3.0).indexOf(3.0) } + } + + @Test + fun indexOf_BooleanArray() { + expect(0) { booleanArrayOf(true, false).indexOf(true) } + expect(1) { booleanArrayOf(true, false).indexOf(false) } + expect(-1) { booleanArrayOf(true).indexOf(false) } + } + + @Test + fun indexOf_CharArray() { + expect(-1) { charArrayOf('a', 'b', 'c').indexOf('z') } + expect(0) { charArrayOf('a', 'b', 'c').indexOf('a') } + expect(1) { charArrayOf('a', 'b', 'c').indexOf('b') } + expect(2) { charArrayOf('a', 'b', 'c').indexOf('c') } + } + + @Test + fun indexOfFirst_Array() { + expect(-1) { arrayOf<Int>(1, 2, 3).indexOfFirst { it == 0 } } + expect(0) { arrayOf<Int>(1, 2, 3).indexOfFirst { it % 2 == 1 } } + expect(1) { arrayOf<Int>(1, 2, 3).indexOfFirst { it % 2 == 0 } } + expect(2) { arrayOf<Int>(1, 2, 3).indexOfFirst { it == 3 } } + expect(-1) { arrayOf("cat", "dog", "bird").indexOfFirst { it.contains("p") } } + expect(0) { arrayOf("cat", "dog", "bird").indexOfFirst { it.startsWith('c') } } + expect(1) { arrayOf("cat", "dog", "bird").indexOfFirst { it.startsWith('d') } } + expect(2) { arrayOf("cat", "dog", "bird").indexOfFirst { it.endsWith('d') } } + } + + @Test + fun indexOfFirst_ByteArray() { + expect(-1) { byteArrayOf(1, 2, 3).indexOfFirst { it == 0.toByte() } } + expect(0) { byteArrayOf(1, 2, 3).indexOfFirst { it % 2 == 1 } } + expect(1) { byteArrayOf(1, 2, 3).indexOfFirst { it % 2 == 0 } } + expect(2) { byteArrayOf(1, 2, 3).indexOfFirst { it == 3.toByte() } } + } + + @Test + fun indexOfFirst_ShortArray() { + expect(-1) { shortArrayOf(1, 2, 3).indexOfFirst { it == 0.toShort() } } + expect(0) { shortArrayOf(1, 2, 3).indexOfFirst { it % 2 == 1 } } + expect(1) { shortArrayOf(1, 2, 3).indexOfFirst { it % 2 == 0 } } + expect(2) { shortArrayOf(1, 2, 3).indexOfFirst { it == 3.toShort() } } + } + + @Test + fun indexOfFirst_IntArray() { + expect(-1) { intArrayOf(1, 2, 3).indexOfFirst { it == 0 } } + expect(0) { intArrayOf(1, 2, 3).indexOfFirst { it % 2 == 1 } } + expect(1) { intArrayOf(1, 2, 3).indexOfFirst { it % 2 == 0 } } + expect(2) { intArrayOf(1, 2, 3).indexOfFirst { it == 3 } } + } + + @Test + fun indexOfFirst_LongArray() { + expect(-1) { longArrayOf(1L, 2L, 3L).indexOfFirst { it == 0L } } + expect(0) { longArrayOf(1L, 2L, 3L).indexOfFirst { it % 2L == 1L } } + expect(1) { longArrayOf(1L, 2L, 3L).indexOfFirst { it % 2L == 0L } } + expect(2) { longArrayOf(1L, 2L, 3L).indexOfFirst { it == 3L } } + } + + @Test + fun indexOfFirst_FloatArray() { + expect(-1) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOfFirst { it == 0.0f } } + expect(0) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOfFirst { it % 2.0f == 1.0f } } + expect(1) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOfFirst { it % 2.0f == 0.0f } } + expect(2) { floatArrayOf(1.0f, 2.0f, 3.0f).indexOfFirst { it == 3.0f } } + } + + @Test + fun indexOfFirst_DoubleArray() { + expect(-1) { doubleArrayOf(1.0, 2.0, 3.0).indexOfFirst { it == 0.0 } } + expect(0) { doubleArrayOf(1.0, 2.0, 3.0).indexOfFirst { it % 2.0 == 1.0 } } + expect(1) { doubleArrayOf(1.0, 2.0, 3.0).indexOfFirst { it % 2.0 == 0.0 } } + expect(2) { doubleArrayOf(1.0, 2.0, 3.0).indexOfFirst { it == 3.0 } } + } + + @Test + fun indexOfFirst_BooleanArray() { + expect(0) { booleanArrayOf(true, false, false, true).indexOfFirst { it } } + expect(1) { booleanArrayOf(true, false, false, true).indexOfFirst { !it } } + expect(-1) { booleanArrayOf(true, true).indexOfFirst { !it } } + } + + @Test + fun indexOfFirst_CharArray() { + expect(-1) { charArrayOf('a', 'b', 'c').indexOfFirst { it == 'z' } } + expect(0) { charArrayOf('a', 'b', 'c').indexOfFirst { it < 'c' } } + expect(1) { charArrayOf('a', 'b', 'c').indexOfFirst { it > 'a' } } + expect(2) { charArrayOf('a', 'b', 'c').indexOfFirst { it != 'a' && it != 'b' } } + } + + @Test + fun copyInto_Array() { + val dest = arrayOf("a", "b", "c") + val newValues = arrayOf("e", "f", "g") + newValues.copyInto(dest, 0, 1, 3) + val result1 = arrayOf("f", "g", "c") + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = arrayOf("g", "c", "c") + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = arrayOf("g", "g", "c") + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_ByteArray() { + val dest = byteArrayOf(1, 2, 3) + val newValues = byteArrayOf(4, 5, 6) + newValues.copyInto(dest, 0, 1, 3) + val result1 = byteArrayOf(5, 6, 3) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = byteArrayOf(6, 3, 3) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = byteArrayOf(6, 6, 3) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_ShortArray() { + val dest = shortArrayOf(1, 2, 3) + val newValues = shortArrayOf(4, 5, 6) + newValues.copyInto(dest, 0, 1, 3) + val result1 = shortArrayOf(5, 6, 3) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = shortArrayOf(6, 3, 3) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = shortArrayOf(6, 6, 3) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_IntArray() { + val dest = intArrayOf(1, 2, 3) + val newValues = intArrayOf(4, 5, 6) + newValues.copyInto(dest, 0, 1, 3) + val result1 = intArrayOf(5, 6, 3) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = intArrayOf(6, 3, 3) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = intArrayOf(6, 6, 3) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_LongArray() { + val dest = longArrayOf(1L, 2L, 3L) + val newValues = longArrayOf(4L, 5L, 6L) + newValues.copyInto(dest, 0, 1, 3) + val result1 = longArrayOf(5L, 6L, 3L) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = longArrayOf(6L, 3L, 3L) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = longArrayOf(6L, 6L, 3L) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_FloatArray() { + val dest = floatArrayOf(1.0f, 2.0f, 3.0f) + val newValues = floatArrayOf(4.0f, 5.0f, 6.0f) + newValues.copyInto(dest, 0, 1, 3) + val result1 = floatArrayOf(5.0f, 6.0f, 3.0f) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = floatArrayOf(6.0f, 3.0f, 3.0f) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = floatArrayOf(6.0f, 6.0f, 3.0f) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_DoubleArray() { + val dest = doubleArrayOf(1.0, 2.0, 3.0) + val newValues = doubleArrayOf(4.0, 5.0, 6.0) + newValues.copyInto(dest, 0, 1, 3) + val result1 = doubleArrayOf(5.0, 6.0, 3.0) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = doubleArrayOf(6.0, 3.0, 3.0) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = doubleArrayOf(6.0, 6.0, 3.0) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_CharArray() { + val dest = charArrayOf('a', 'b', 'c') + val newValues = charArrayOf('e', 'f', 'g') + newValues.copyInto(dest, 0, 1, 3) + val result1 = charArrayOf('f', 'g', 'c') + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = charArrayOf('g', 'c', 'c') + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = charArrayOf('g', 'g', 'c') + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun reverse_Array() { + val arrays = (0..4).map { n -> (1..n).map { it.toString() }.toTypedArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_ByteArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toByte() }.toByteArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_ShortArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toShort() }.toShortArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_IntArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toInt() }.toIntArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_LongArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toLong() }.toLongArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_FloatArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toFloat() }.toFloatArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_DoubleArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toDouble() }.toDoubleArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_BooleanArray() { + val arrays = (0..4).map { n -> (1..n).map { it % 2 == 0 }.toBooleanArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_CharArray() { + val arrays = (0..4).map { n -> (1..n).map { 'a' + it }.toCharArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverseRange_Array() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toString() }.toTypedArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_ByteArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toByte() }.toByteArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_ShortArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toShort() }.toShortArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_IntArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toInt() }.toIntArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_LongArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toLong() }.toLongArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_FloatArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toFloat() }.toFloatArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_DoubleArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toDouble() }.toDoubleArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_BooleanArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it % 2 == 0 }.toBooleanArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_CharArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { 'a' + it }.toCharArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reversed_Array() { + assertEquals(listOf<Int>(3, 2, 1), arrayOf<Int>(1, 2, 3).reversed()) + assertEquals(listOf("3", "2", "1"), arrayOf("1", "2", "3").reversed()) + } + + @Test + fun reversed_ByteArray() { + assertEquals(listOf<Byte>(3, 2, 1), byteArrayOf(1, 2, 3).reversed()) + } + + @Test + fun reversed_ShortArray() { + assertEquals(listOf<Short>(3, 2, 1), shortArrayOf(1, 2, 3).reversed()) + } + + @Test + fun reversed_IntArray() { + assertEquals(listOf<Int>(3, 2, 1), intArrayOf(1, 2, 3).reversed()) + } + + @Test + fun reversed_LongArray() { + assertEquals(listOf<Long>(3L, 2L, 1L), longArrayOf(1L, 2L, 3L).reversed()) + } + + @Test + fun reversed_FloatArray() { + assertEquals(listOf<Float>(3.0f, 2.0f, 1.0f), floatArrayOf(1.0f, 2.0f, 3.0f).reversed()) + } + + @Test + fun reversed_DoubleArray() { + assertEquals(listOf<Double>(3.0, 2.0, 1.0), doubleArrayOf(1.0, 2.0, 3.0).reversed()) + } + + @Test + fun reversed_BooleanArray() { + assertEquals(listOf(false, false, true), booleanArrayOf(true, false, false).reversed()) + } + + @Test + fun reversed_CharArray() { + assertEquals(listOf('3', '2', '1'), charArrayOf('1', '2', '3').reversed()) + } + + @Test + fun reversedArray_Array() { + assertArrayContentEquals(arrayOf<Int>(3, 2, 1), arrayOf<Int>(1, 2, 3).reversedArray()) + assertArrayContentEquals(arrayOf("3", "2", "1"), arrayOf("1", "2", "3").reversedArray()) + } + + @Test + fun reversedArray_ByteArray() { + assertArrayContentEquals(byteArrayOf(3, 2, 1), byteArrayOf(1, 2, 3).reversedArray()) + } + + @Test + fun reversedArray_ShortArray() { + assertArrayContentEquals(shortArrayOf(3, 2, 1), shortArrayOf(1, 2, 3).reversedArray()) + } + + @Test + fun reversedArray_IntArray() { + assertArrayContentEquals(intArrayOf(3, 2, 1), intArrayOf(1, 2, 3).reversedArray()) + } + + @Test + fun reversedArray_LongArray() { + assertArrayContentEquals(longArrayOf(3L, 2L, 1L), longArrayOf(1L, 2L, 3L).reversedArray()) + } + + @Test + fun reversedArray_FloatArray() { + assertArrayContentEquals(floatArrayOf(3.0f, 2.0f, 1.0f), floatArrayOf(1.0f, 2.0f, 3.0f).reversedArray()) + } + + @Test + fun reversedArray_DoubleArray() { + assertArrayContentEquals(doubleArrayOf(3.0, 2.0, 1.0), doubleArrayOf(1.0, 2.0, 3.0).reversedArray()) + } + + @Test + fun reversedArray_BooleanArray() { + assertArrayContentEquals(booleanArrayOf(false, false, true), booleanArrayOf(true, false, false).reversedArray()) + } + + @Test + fun reversedArray_CharArray() { + assertArrayContentEquals(charArrayOf('3', '2', '1'), charArrayOf('1', '2', '3').reversedArray()) + } + + @Test + fun shuffle_Array() { + fun test(data: Array<*>) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(Array(100) { it.toInt() }) + test(arrayOf(1, "x", null, Any(), 'a', 2u, 5.0)) + } + + @Test + fun shuffle_ByteArray() { + fun test(data: ByteArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(ByteArray(100) { it.toByte() }) + } + + @Test + fun shuffle_ShortArray() { + fun test(data: ShortArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(ShortArray(100) { it.toShort() }) + } + + @Test + fun shuffle_IntArray() { + fun test(data: IntArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(IntArray(100) { it.toInt() }) + } + + @Test + fun shuffle_LongArray() { + fun test(data: LongArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(LongArray(100) { it.toLong() }) + } + + @Test + fun shuffle_FloatArray() { + fun test(data: FloatArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(FloatArray(100) { it.toFloat() }) + } + + @Test + fun shuffle_DoubleArray() { + fun test(data: DoubleArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(DoubleArray(100) { it.toDouble() }) + } + + @Test + fun shuffle_BooleanArray() { + fun test(data: BooleanArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(BooleanArray(100) { it % 2 == 0 }) + } + + @Test + fun shuffle_CharArray() { + fun test(data: CharArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(CharArray(100) { it.toChar() }) + } + + @Test + fun shuffleRandom_Array() { + fun test(data: Array<*>) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(Array(16) { it.toInt() }) + test(arrayOf(1, "x", null, Any(), 'a', 2u, 5.0)) + } + + @Test + fun shuffleRandom_ByteArray() { + fun test(data: ByteArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(ByteArray(16) { it.toByte() }) + } + + @Test + fun shuffleRandom_ShortArray() { + fun test(data: ShortArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(ShortArray(16) { it.toShort() }) + } + + @Test + fun shuffleRandom_IntArray() { + fun test(data: IntArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(IntArray(16) { it.toInt() }) + } + + @Test + fun shuffleRandom_LongArray() { + fun test(data: LongArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(LongArray(16) { it.toLong() }) + } + + @Test + fun shuffleRandom_FloatArray() { + fun test(data: FloatArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(FloatArray(16) { it.toFloat() }) + } + + @Test + fun shuffleRandom_DoubleArray() { + fun test(data: DoubleArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(DoubleArray(16) { it.toDouble() }) + } + + @Test + fun shuffleRandom_BooleanArray() { + fun test(data: BooleanArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(BooleanArray(16) { it % 2 == 0 }) + } + + @Test + fun shuffleRandom_CharArray() { + fun test(data: CharArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(CharArray(16) { it.toChar() }) + } + + @Test + fun sort_Array() { + val data = arrayOf(5, 2, 1, 9, 80, Int.MIN_VALUE, Int.MAX_VALUE) + data.sort() + assertArrayContentEquals(arrayOf(Int.MIN_VALUE, 1, 2, 5, 9, 80, Int.MAX_VALUE), data) + val strings = arrayOf("9", "80", "all", "Foo") + strings.sort() + assertArrayContentEquals(arrayOf("80", "9", "Foo", "all"), strings) + } + + @Test + fun sort_ByteArray() { + val data = byteArrayOf(5, 2, 1, 9, 80, Byte.MIN_VALUE, Byte.MAX_VALUE) + data.sort() + assertArrayContentEquals(byteArrayOf(Byte.MIN_VALUE, 1, 2, 5, 9, 80, Byte.MAX_VALUE), data) + } + + @Test + fun sort_ShortArray() { + val data = shortArrayOf(5, 2, 1, 9, 80, Short.MIN_VALUE, Short.MAX_VALUE) + data.sort() + assertArrayContentEquals(shortArrayOf(Short.MIN_VALUE, 1, 2, 5, 9, 80, Short.MAX_VALUE), data) + } + + @Test + fun sort_IntArray() { + val data = intArrayOf(5, 2, 1, 9, 80, Int.MIN_VALUE, Int.MAX_VALUE) + data.sort() + assertArrayContentEquals(intArrayOf(Int.MIN_VALUE, 1, 2, 5, 9, 80, Int.MAX_VALUE), data) + } + + @Test + fun sort_LongArray() { + val data = longArrayOf(5L, 2L, 1L, 9L, 80L, Long.MIN_VALUE, Long.MAX_VALUE) + data.sort() + assertArrayContentEquals(longArrayOf(Long.MIN_VALUE, 1L, 2L, 5L, 9L, 80L, Long.MAX_VALUE), data) + } + + @Test + fun sort_FloatArray() { + val data = floatArrayOf(5.0f, 2.0f, 1.0f, 9.0f, 80.0f, Float.MIN_VALUE, Float.MAX_VALUE) + data.sort() + assertArrayContentEquals(floatArrayOf(Float.MIN_VALUE, 1.0f, 2.0f, 5.0f, 9.0f, 80.0f, Float.MAX_VALUE), data) + } + + @Test + fun sort_DoubleArray() { + val data = doubleArrayOf(5.0, 2.0, 1.0, 9.0, 80.0, Double.MIN_VALUE, Double.MAX_VALUE) + data.sort() + assertArrayContentEquals(doubleArrayOf(Double.MIN_VALUE, 1.0, 2.0, 5.0, 9.0, 80.0, Double.MAX_VALUE), data) + } + + @Test + fun sort_CharArray() { + val data = charArrayOf('d', 'c', 'E', 'a', '\u0000', '\uFFFF') + data.sort() + assertArrayContentEquals(charArrayOf('\u0000', 'E', 'a', 'c', 'd', '\uFFFF'), data) + } + + @Test + fun sortBy_Array() { + val data = arrayOf("aa" to 20, "ab" to 3, "aa" to 3) + data.sortBy { it.second } + assertArrayContentEquals(arrayOf("ab" to 3, "aa" to 3, "aa" to 20), data) + data.sortBy { it.first } + assertArrayContentEquals(arrayOf("aa" to 3, "aa" to 20, "ab" to 3), data) + data.sortBy { (it.first + it.second).length } + assertArrayContentEquals(arrayOf("aa" to 3, "ab" to 3, "aa" to 20), data) + } + + @Test + fun sortByDescending_Array() { + val data = arrayOf("aa" to 20, "ab" to 3, "aa" to 3) + data.sortByDescending { it.second } + assertArrayContentEquals(arrayOf("aa" to 20, "ab" to 3, "aa" to 3), data) + data.sortByDescending { it.first } + assertArrayContentEquals(arrayOf("ab" to 3, "aa" to 20, "aa" to 3), data) + data.sortByDescending { (it.first + it.second).length } + assertArrayContentEquals(arrayOf("aa" to 20, "ab" to 3, "aa" to 3), data) + } + + @Test + fun sortDescending_Array() { + val data = arrayOf(5, 2, 1, 9, 80, Int.MIN_VALUE, Int.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(arrayOf(Int.MIN_VALUE, 1, 2, 5, 9, 80, Int.MAX_VALUE).reversedArray(), data) + val strings = arrayOf("9", "80", "all", "Foo") + strings.sortDescending() + assertArrayContentEquals(arrayOf("80", "9", "Foo", "all").reversedArray(), strings) + } + + @Test + fun sortDescending_ByteArray() { + val data = byteArrayOf(5, 2, 1, 9, 80, Byte.MIN_VALUE, Byte.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(byteArrayOf(Byte.MIN_VALUE, 1, 2, 5, 9, 80, Byte.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sortDescending_ShortArray() { + val data = shortArrayOf(5, 2, 1, 9, 80, Short.MIN_VALUE, Short.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(shortArrayOf(Short.MIN_VALUE, 1, 2, 5, 9, 80, Short.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sortDescending_IntArray() { + val data = intArrayOf(5, 2, 1, 9, 80, Int.MIN_VALUE, Int.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(intArrayOf(Int.MIN_VALUE, 1, 2, 5, 9, 80, Int.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sortDescending_LongArray() { + val data = longArrayOf(5L, 2L, 1L, 9L, 80L, Long.MIN_VALUE, Long.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(longArrayOf(Long.MIN_VALUE, 1L, 2L, 5L, 9L, 80L, Long.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sortDescending_FloatArray() { + val data = floatArrayOf(5.0f, 2.0f, 1.0f, 9.0f, 80.0f, Float.MIN_VALUE, Float.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(floatArrayOf(Float.MIN_VALUE, 1.0f, 2.0f, 5.0f, 9.0f, 80.0f, Float.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sortDescending_DoubleArray() { + val data = doubleArrayOf(5.0, 2.0, 1.0, 9.0, 80.0, Double.MIN_VALUE, Double.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(doubleArrayOf(Double.MIN_VALUE, 1.0, 2.0, 5.0, 9.0, 80.0, Double.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sortDescending_CharArray() { + val data = charArrayOf('d', 'c', 'E', 'a', '\u0000', '\uFFFF') + data.sortDescending() + assertArrayContentEquals(charArrayOf('\u0000', 'E', 'a', 'c', 'd', '\uFFFF').reversedArray(), data) + } + + @Test + fun sorted_Array() { + arrayOf<Int>(3, 7, 1).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + arrayOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + arrayOf("ac", "aD", "aba").sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_ByteArray() { + byteArrayOf(3, 7, 1).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + byteArrayOf(1, Byte.MAX_VALUE, Byte.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_ShortArray() { + shortArrayOf(3, 7, 1).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + shortArrayOf(1, Short.MAX_VALUE, Short.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_IntArray() { + intArrayOf(3, 7, 1).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + intArrayOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_LongArray() { + longArrayOf(3L, 7L, 1L).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + longArrayOf(1L, Long.MAX_VALUE, Long.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_FloatArray() { + floatArrayOf(3.0f, 7.0f, 1.0f).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + floatArrayOf(1.0f, Float.MAX_VALUE, Float.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + floatArrayOf(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.MAX_VALUE, -Float.MAX_VALUE, 1.0f, -1.0f, + Float.MIN_VALUE, -Float.MIN_VALUE, 0.0f, -0.0f, Float.NaN).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_DoubleArray() { + doubleArrayOf(3.0, 7.0, 1.0).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + doubleArrayOf(1.0, Double.MAX_VALUE, Double.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + doubleArrayOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, -Double.MAX_VALUE, 1.0, -1.0, + Double.MIN_VALUE, -Double.MIN_VALUE, 0.0, -0.0, Double.NaN).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_CharArray() { + charArrayOf('a', 'D', 'c').sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_Array() { + arrayOf<Int>(3, 7, 1).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + arrayOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + arrayOf("ac", "aD", "aba").sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_ByteArray() { + byteArrayOf(3, 7, 1).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + byteArrayOf(1, Byte.MAX_VALUE, Byte.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_ShortArray() { + shortArrayOf(3, 7, 1).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + shortArrayOf(1, Short.MAX_VALUE, Short.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_IntArray() { + intArrayOf(3, 7, 1).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + intArrayOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_LongArray() { + longArrayOf(3L, 7L, 1L).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + longArrayOf(1L, Long.MAX_VALUE, Long.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_FloatArray() { + floatArrayOf(3.0f, 7.0f, 1.0f).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + floatArrayOf(1.0f, Float.MAX_VALUE, Float.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + floatArrayOf(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.MAX_VALUE, -Float.MAX_VALUE, 1.0f, -1.0f, + Float.MIN_VALUE, -Float.MIN_VALUE, 0.0f, -0.0f, Float.NaN).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_DoubleArray() { + doubleArrayOf(3.0, 7.0, 1.0).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + doubleArrayOf(1.0, Double.MAX_VALUE, Double.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + doubleArrayOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, -Double.MAX_VALUE, 1.0, -1.0, + Double.MIN_VALUE, -Double.MIN_VALUE, 0.0, -0.0, Double.NaN).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_CharArray() { + charArrayOf('a', 'D', 'c').sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArrayDescending_Array() { + arrayOf<Int>(3, 7, 1).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + arrayOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + arrayOf("ac", "aD", "aba").sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_ByteArray() { + byteArrayOf(3, 7, 1).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + byteArrayOf(1, Byte.MAX_VALUE, Byte.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_ShortArray() { + shortArrayOf(3, 7, 1).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + shortArrayOf(1, Short.MAX_VALUE, Short.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_IntArray() { + intArrayOf(3, 7, 1).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + intArrayOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_LongArray() { + longArrayOf(3L, 7L, 1L).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + longArrayOf(1L, Long.MAX_VALUE, Long.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_FloatArray() { + floatArrayOf(3.0f, 7.0f, 1.0f).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + floatArrayOf(1.0f, Float.MAX_VALUE, Float.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + floatArrayOf(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.MAX_VALUE, -Float.MAX_VALUE, 1.0f, -1.0f, + Float.MIN_VALUE, -Float.MIN_VALUE, 0.0f, -0.0f, Float.NaN).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_DoubleArray() { + doubleArrayOf(3.0, 7.0, 1.0).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + doubleArrayOf(1.0, Double.MAX_VALUE, Double.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + doubleArrayOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, -Double.MAX_VALUE, 1.0, -1.0, + Double.MIN_VALUE, -Double.MIN_VALUE, 0.0, -0.0, Double.NaN).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_CharArray() { + charArrayOf('a', 'D', 'c').sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayWith_Array() { + val comparator = compareBy { it: Int -> it % 3 }.thenByDescending { it } + arrayOf<Int>(0, 1, 2, 3, 4, 5).sortedArrayWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + val comparator1 = compareBy<String> { it.toUpperCase().reversed() } + val data = arrayOf("cat", "dad", "BAD") + assertArrayContentEquals(arrayOf("BAD", "dad", "cat"), data.sortedArrayWith(comparator1)) + assertArrayContentEquals(arrayOf("cat", "dad", "BAD"), data.sortedArrayWith(comparator1.reversed())) + assertArrayContentEquals(arrayOf("BAD", "dad", "cat"), data.sortedArrayWith(comparator1.reversed().reversed())) + } + + @Test + fun sortedBy_Array() { + val values = arrayOf("ac", "aD", "aba") + val indices = arrayOf<Int>(0, 1, 2) + assertEquals(listOf<Int>(1, 2, 0), indices.sortedBy { values[it.toInt()] }) + assertEquals(listOf("two" to 3, "three" to 20), arrayOf("three" to 20, "two" to 3).sortedBy { it.second }) + assertEquals(listOf("three" to 20, "two" to 3), arrayOf("three" to 20, "two" to 3).sortedBy { it.first }) + } + + @Test + fun sortedBy_ByteArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = byteArrayOf(0, 1, 2) + assertEquals(listOf<Byte>(1, 2, 0), indices.sortedBy { values[it.toInt()] }) + } + + @Test + fun sortedBy_ShortArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = shortArrayOf(0, 1, 2) + assertEquals(listOf<Short>(1, 2, 0), indices.sortedBy { values[it.toInt()] }) + } + + @Test + fun sortedBy_IntArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = intArrayOf(0, 1, 2) + assertEquals(listOf<Int>(1, 2, 0), indices.sortedBy { values[it.toInt()] }) + } + + @Test + fun sortedBy_LongArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = longArrayOf(0L, 1L, 2L) + assertEquals(listOf<Long>(1L, 2L, 0L), indices.sortedBy { values[it.toInt()] }) + } + + @Test + fun sortedBy_FloatArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = floatArrayOf(0.0f, 1.0f, 2.0f) + assertEquals(listOf<Float>(1.0f, 2.0f, 0.0f), indices.sortedBy { values[it.toInt()] }) + } + + @Test + fun sortedBy_DoubleArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = doubleArrayOf(0.0, 1.0, 2.0) + assertEquals(listOf<Double>(1.0, 2.0, 0.0), indices.sortedBy { values[it.toInt()] }) + } + + @Test + fun sortedByDescending_Array() { + val values = arrayOf("ac", "aD", "aba") + val indices = arrayOf<Int>(0, 1, 2) + assertEquals(listOf<Int>(1, 2, 0).reversed(), indices.sortedByDescending { values[it.toInt()] }) + assertEquals(listOf("two" to 3, "three" to 20).reversed(), arrayOf("three" to 20, "two" to 3).sortedByDescending { it.second }) + assertEquals(listOf("three" to 20, "two" to 3).reversed(), arrayOf("three" to 20, "two" to 3).sortedByDescending { it.first }) + } + + @Test + fun sortedByDescending_ByteArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = byteArrayOf(0, 1, 2) + assertEquals(listOf<Byte>(1, 2, 0).reversed(), indices.sortedByDescending { values[it.toInt()] }) + } + + @Test + fun sortedByDescending_ShortArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = shortArrayOf(0, 1, 2) + assertEquals(listOf<Short>(1, 2, 0).reversed(), indices.sortedByDescending { values[it.toInt()] }) + } + + @Test + fun sortedByDescending_IntArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = intArrayOf(0, 1, 2) + assertEquals(listOf<Int>(1, 2, 0).reversed(), indices.sortedByDescending { values[it.toInt()] }) + } + + @Test + fun sortedByDescending_LongArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = longArrayOf(0L, 1L, 2L) + assertEquals(listOf<Long>(1L, 2L, 0L).reversed(), indices.sortedByDescending { values[it.toInt()] }) + } + + @Test + fun sortedByDescending_FloatArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = floatArrayOf(0.0f, 1.0f, 2.0f) + assertEquals(listOf<Float>(1.0f, 2.0f, 0.0f).reversed(), indices.sortedByDescending { values[it.toInt()] }) + } + + @Test + fun sortedByDescending_DoubleArray() { + val values = arrayOf("ac", "aD", "aba") + val indices = doubleArrayOf(0.0, 1.0, 2.0) + assertEquals(listOf<Double>(1.0, 2.0, 0.0).reversed(), indices.sortedByDescending { values[it.toInt()] }) + } + + @Test + fun sortedDescending_Array() { + arrayOf<Int>(3, 7, 1).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + arrayOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + arrayOf("ac", "aD", "aba").sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_ByteArray() { + byteArrayOf(3, 7, 1).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + byteArrayOf(1, Byte.MAX_VALUE, Byte.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_ShortArray() { + shortArrayOf(3, 7, 1).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + shortArrayOf(1, Short.MAX_VALUE, Short.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_IntArray() { + intArrayOf(3, 7, 1).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + intArrayOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_LongArray() { + longArrayOf(3L, 7L, 1L).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + longArrayOf(1L, Long.MAX_VALUE, Long.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_FloatArray() { + floatArrayOf(3.0f, 7.0f, 1.0f).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + floatArrayOf(1.0f, Float.MAX_VALUE, Float.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + floatArrayOf(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.MAX_VALUE, -Float.MAX_VALUE, 1.0f, -1.0f, + Float.MIN_VALUE, -Float.MIN_VALUE, 0.0f, -0.0f, Float.NaN).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_DoubleArray() { + doubleArrayOf(3.0, 7.0, 1.0).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + doubleArrayOf(1.0, Double.MAX_VALUE, Double.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + doubleArrayOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, -Double.MAX_VALUE, 1.0, -1.0, + Double.MIN_VALUE, -Double.MIN_VALUE, 0.0, -0.0, Double.NaN).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_CharArray() { + charArrayOf('a', 'D', 'c').sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedWith_Array() { + val comparator = compareBy { it: Int -> it % 3 }.thenByDescending { it } + arrayOf<Int>(0, 1, 2, 3, 4, 5).sortedWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + val comparator1 = compareBy<String> { it.toUpperCase().reversed() } + val data = arrayOf("cat", "dad", "BAD") + assertEquals(listOf("BAD", "dad", "cat"), data.sortedWith(comparator1)) + assertEquals(listOf("cat", "dad", "BAD"), data.sortedWith(comparator1.reversed())) + assertEquals(listOf("BAD", "dad", "cat"), data.sortedWith(comparator1.reversed().reversed())) + } + + @Test + fun sortedWith_ByteArray() { + val comparator = compareBy { it: Byte -> it % 3 }.thenByDescending { it } + byteArrayOf(0, 1, 2, 3, 4, 5).sortedWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + } + + @Test + fun sortedWith_ShortArray() { + val comparator = compareBy { it: Short -> it % 3 }.thenByDescending { it } + shortArrayOf(0, 1, 2, 3, 4, 5).sortedWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + } + + @Test + fun sortedWith_IntArray() { + val comparator = compareBy { it: Int -> it % 3 }.thenByDescending { it } + intArrayOf(0, 1, 2, 3, 4, 5).sortedWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + } + + @Test + fun sortedWith_LongArray() { + val comparator = compareBy { it: Long -> it % 3L }.thenByDescending { it } + longArrayOf(0L, 1L, 2L, 3L, 4L, 5L).sortedWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + } + + @Test + fun sortedWith_FloatArray() { + val comparator = compareBy { it: Float -> it % 3.0f }.thenByDescending { it } + floatArrayOf(0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f).sortedWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + } + + @Test + fun sortedWith_DoubleArray() { + val comparator = compareBy { it: Double -> it % 3.0 }.thenByDescending { it } + doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0).sortedWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + } + +}
diff --git a/libraries/stdlib/test/generated/_CollectionsTest.kt b/libraries/stdlib/test/generated/_CollectionsTest.kt new file mode 100644 index 0000000..f59c2ce --- /dev/null +++ b/libraries/stdlib/test/generated/_CollectionsTest.kt
@@ -0,0 +1,234 @@ +/* + * 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 + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLibTests.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import test.comparisons.STRING_CASE_INSENSITIVE_ORDER +import kotlin.random.* +import kotlin.test.* + +class _CollectionsTest { + @Test + fun foldIndexed_Iterable() { + expect(8) { listOf<Int>(1, 2, 3).foldIndexed(0) { i, acc, e -> acc + i.toInt() * e } } + expect(10) { listOf<Int>(1, 2, 3).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15) { listOf<Int>(1, 2, 3).foldIndexed(1) { i, acc, e -> acc * (i.toInt() + e) } } + expect(" 0-1 1-2 2-3") { listOf<Int>(1, 2, 3).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42) { + val numbers = listOf<Int>(1, 2, 3, 4) + numbers.foldIndexed(0) { index, a, b -> index.toInt() * (a + b) } + } + expect(0) { + val numbers = listOf<Int>() + numbers.foldIndexed(0) { index, a, b -> index.toInt() * (a + b) } + } + expect("11234") { + val numbers = listOf<Int>(1, 2, 3, 4) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldRightIndexed_List() { + expect(8) { listOf<Int>(1, 2, 3).foldRightIndexed(0) { i, e, acc -> acc + i.toInt() * e } } + expect(10) { listOf<Int>(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15) { listOf<Int>(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc * (i.toInt() + e) } } + expect(" 2-3 1-2 0-1") { listOf<Int>(1, 2, 3).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = listOf<Int>(1, 2, 3, 4) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun maxByOrNull_Iterable() { + assertEquals(null, listOf<Int>().maxByOrNull { it }) + assertEquals(1, listOf<Int>(1).maxByOrNull { it }) + assertEquals(3, listOf<Int>(3, 2).maxByOrNull { it * it }) + assertEquals(3, listOf<Int>(3, 2).maxByOrNull { "a" }) + assertEquals(3, listOf<Int>(3, 2).maxByOrNull { it.toString() }) + assertEquals(2, listOf<Int>(2, 3).maxByOrNull { -it }) + assertEquals('b', listOf('a', 'b').maxByOrNull { "x$it" }) + assertEquals("abc", listOf("b", "abc").maxByOrNull { it.length }) + } + + @Test + fun maxWithOrNull_Iterable() { + assertEquals(null, listOf<Int>().maxWithOrNull(naturalOrder())) + assertEquals(1, listOf<Int>(1).maxWithOrNull(naturalOrder())) + assertEquals(3, listOf<Int>(2, 3, 4).maxWithOrNull(compareBy { it % 4 })) + assertEquals("B", listOf("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) + } + + @Test + fun minByOrNull_Iterable() { + assertEquals(null, listOf<Int>().minByOrNull { it }) + assertEquals(1, listOf<Int>(1).minByOrNull { it }) + assertEquals(2, listOf<Int>(3, 2).minByOrNull { it * it }) + assertEquals(3, listOf<Int>(3, 2).minByOrNull { "a" }) + assertEquals(2, listOf<Int>(3, 2).minByOrNull { it.toString() }) + assertEquals(3, listOf<Int>(2, 3).minByOrNull { -it }) + assertEquals('a', listOf('a', 'b').minByOrNull { "x$it" }) + assertEquals("b", listOf("b", "abc").minByOrNull { it.length }) + } + + @Test + fun minWithOrNull_Iterable() { + assertEquals(null, listOf<Int>().minWithOrNull(naturalOrder())) + assertEquals(1, listOf<Int>(1).minWithOrNull(naturalOrder())) + assertEquals(4, listOf<Int>(2, 3, 4).minWithOrNull(compareBy { it % 4 })) + assertEquals("a", listOf("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) + } + + @Test + fun indexOf_List() { + expect(-1) { listOf<Int>(1, 2, 3).indexOf(0) } + expect(0) { listOf<Int>(1, 2, 3).indexOf(1) } + expect(1) { listOf<Int>(1, 2, 3).indexOf(2) } + expect(2) { listOf<Int>(1, 2, 3).indexOf(3) } + expect(-1) { listOf("cat", "dog", "bird").indexOf("mouse") } + expect(0) { listOf("cat", "dog", "bird").indexOf("cat") } + expect(1) { listOf("cat", "dog", "bird").indexOf("dog") } + expect(2) { listOf("cat", "dog", "bird").indexOf("bird") } + expect(0) { listOf(null, "dog", null).indexOf(null as String?)} + } + + @Test + fun indexOfFirst_List() { + expect(-1) { listOf<Int>(1, 2, 3).indexOfFirst { it == 0 } } + expect(0) { listOf<Int>(1, 2, 3).indexOfFirst { it % 2 == 1 } } + expect(1) { listOf<Int>(1, 2, 3).indexOfFirst { it % 2 == 0 } } + expect(2) { listOf<Int>(1, 2, 3).indexOfFirst { it == 3 } } + expect(-1) { listOf("cat", "dog", "bird").indexOfFirst { it.contains("p") } } + expect(0) { listOf("cat", "dog", "bird").indexOfFirst { it.startsWith('c') } } + expect(1) { listOf("cat", "dog", "bird").indexOfFirst { it.startsWith('d') } } + expect(2) { listOf("cat", "dog", "bird").indexOfFirst { it.endsWith('d') } } + } + + @Test + fun reversed_Iterable() { + assertEquals(listOf<Int>(3, 2, 1), listOf<Int>(1, 2, 3).reversed()) + assertEquals(listOf("3", "2", "1"), listOf("1", "2", "3").reversed()) + } + + @Test + fun shuffle_List() { + fun test(data: MutableList<*>) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(MutableList(100) { it.toInt() }) + test(mutableListOf(1, "x", null, Any(), 'a', 2u, 5.0)) + } + + @Test + fun shuffleRandom_List() { + fun test(data: MutableList<*>) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(MutableList(16) { it.toInt() }) + test(mutableListOf(1, "x", null, Any(), 'a', 2u, 5.0)) + } + + @Test + fun sort_List() { + val data = mutableListOf(5, 2, 1, 9, 80, Int.MIN_VALUE, Int.MAX_VALUE) + data.sort() + assertEquals(listOf(Int.MIN_VALUE, 1, 2, 5, 9, 80, Int.MAX_VALUE), data) + val strings = mutableListOf("9", "80", "all", "Foo") + strings.sort() + assertEquals(listOf("80", "9", "Foo", "all"), strings) + } + + @Test + fun sortBy_List() { + val data = mutableListOf("aa" to 20, "ab" to 3, "aa" to 3) + data.sortBy { it.second } + assertEquals(listOf("ab" to 3, "aa" to 3, "aa" to 20), data) + data.sortBy { it.first } + assertEquals(listOf("aa" to 3, "aa" to 20, "ab" to 3), data) + data.sortBy { (it.first + it.second).length } + assertEquals(listOf("aa" to 3, "ab" to 3, "aa" to 20), data) + } + + @Test + fun sortByDescending_List() { + val data = mutableListOf("aa" to 20, "ab" to 3, "aa" to 3) + data.sortByDescending { it.second } + assertEquals(listOf("aa" to 20, "ab" to 3, "aa" to 3), data) + data.sortByDescending { it.first } + assertEquals(listOf("ab" to 3, "aa" to 20, "aa" to 3), data) + data.sortByDescending { (it.first + it.second).length } + assertEquals(listOf("aa" to 20, "ab" to 3, "aa" to 3), data) + } + + @Test + fun sortDescending_List() { + val data = mutableListOf(5, 2, 1, 9, 80, Int.MIN_VALUE, Int.MAX_VALUE) + data.sortDescending() + assertEquals(listOf(Int.MIN_VALUE, 1, 2, 5, 9, 80, Int.MAX_VALUE).reversed(), data) + val strings = mutableListOf("9", "80", "all", "Foo") + strings.sortDescending() + assertEquals(listOf("80", "9", "Foo", "all").reversed(), strings) + } + + @Test + fun sorted_Iterable() { + listOf<Int>(3, 7, 1).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + listOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + listOf("ac", "aD", "aba").sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedBy_List() { + val values = arrayOf("ac", "aD", "aba") + val indices = listOf<Int>(0, 1, 2) + assertEquals(listOf<Int>(1, 2, 0), indices.sortedBy { values[it.toInt()] }) + assertEquals(listOf("two" to 3, "three" to 20), listOf("three" to 20, "two" to 3).sortedBy { it.second }) + assertEquals(listOf("three" to 20, "two" to 3), listOf("three" to 20, "two" to 3).sortedBy { it.first }) + } + + @Test + fun sortedByDescending_List() { + val values = arrayOf("ac", "aD", "aba") + val indices = listOf<Int>(0, 1, 2) + assertEquals(listOf<Int>(1, 2, 0).reversed(), indices.sortedByDescending { values[it.toInt()] }) + assertEquals(listOf("two" to 3, "three" to 20).reversed(), listOf("three" to 20, "two" to 3).sortedByDescending { it.second }) + assertEquals(listOf("three" to 20, "two" to 3).reversed(), listOf("three" to 20, "two" to 3).sortedByDescending { it.first }) + } + + @Test + fun sortedDescending_Iterable() { + listOf<Int>(3, 7, 1).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + listOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + listOf("ac", "aD", "aba").sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedWith_Iterable() { + val comparator = compareBy { it: Int -> it % 3 }.thenByDescending { it } + listOf<Int>(0, 1, 2, 3, 4, 5).sortedWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + val comparator1 = compareBy<String> { it.toUpperCase().reversed() } + val data = listOf("cat", "dad", "BAD") + assertEquals(listOf("BAD", "dad", "cat"), data.sortedWith(comparator1)) + assertEquals(listOf("cat", "dad", "BAD"), data.sortedWith(comparator1.reversed())) + assertEquals(listOf("BAD", "dad", "cat"), data.sortedWith(comparator1.reversed().reversed())) + } + +}
diff --git a/libraries/stdlib/test/generated/_ComparisonsTest.kt b/libraries/stdlib/test/generated/_ComparisonsTest.kt new file mode 100644 index 0000000..4815097 --- /dev/null +++ b/libraries/stdlib/test/generated/_ComparisonsTest.kt
@@ -0,0 +1,463 @@ +/* + * 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.comparisons + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLibTests.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.random.* +import kotlin.test.* + +class _ComparisonsTest { + @Test + fun maxOf_2_Generic() { + expect(2) { maxOf<Int>(2, 1) } + expect(126) { maxOf<Int>(58, 126) } + expect(23) { maxOf<Int>(Random.nextInt(Int.MIN_VALUE, 23), 23) } + expect(Int.MAX_VALUE) { maxOf<Int>(Int.MIN_VALUE, Int.MAX_VALUE) } + expect(Int.MIN_VALUE) { maxOf<Int>(Int.MIN_VALUE, Int.MIN_VALUE) } + } + + @Test + fun maxOf_2_Int() { + expect(2) { maxOf(2, 1) } + expect(126) { maxOf(58, 126) } + expect(23) { maxOf(Random.nextInt(Int.MIN_VALUE, 23), 23) } + expect(Int.MAX_VALUE) { maxOf(Int.MIN_VALUE, Int.MAX_VALUE) } + expect(Int.MIN_VALUE) { maxOf(Int.MIN_VALUE, Int.MIN_VALUE) } + } + + @Test + fun maxOf_2_Long() { + expect(2L) { maxOf(2L, 1L) } + expect(126L) { maxOf(58L, 126L) } + expect(23L) { maxOf(Random.nextLong(Long.MIN_VALUE, 23L), 23L) } + expect(Long.MAX_VALUE) { maxOf(Long.MIN_VALUE, Long.MAX_VALUE) } + expect(Long.MIN_VALUE) { maxOf(Long.MIN_VALUE, Long.MIN_VALUE) } + } + + @Test + fun maxOf_2_Byte() { + expect(2.toByte()) { maxOf(2.toByte(), 1.toByte()) } + expect(126.toByte()) { maxOf(58.toByte(), 126.toByte()) } + expect(23.toByte()) { maxOf(Random.nextInt(Byte.MIN_VALUE.toInt(), 23).toByte(), 23.toByte()) } + expect(Byte.MAX_VALUE) { maxOf(Byte.MIN_VALUE, Byte.MAX_VALUE) } + expect(Byte.MIN_VALUE) { maxOf(Byte.MIN_VALUE, Byte.MIN_VALUE) } + } + + @Test + fun maxOf_2_Short() { + expect(2.toShort()) { maxOf(2.toShort(), 1.toShort()) } + expect(126.toShort()) { maxOf(58.toShort(), 126.toShort()) } + expect(23.toShort()) { maxOf(Random.nextInt(Short.MIN_VALUE.toInt(), 23).toShort(), 23.toShort()) } + expect(Short.MAX_VALUE) { maxOf(Short.MIN_VALUE, Short.MAX_VALUE) } + expect(Short.MIN_VALUE) { maxOf(Short.MIN_VALUE, Short.MIN_VALUE) } + } + + @Test + fun maxOf_2_Double() { + expect(2.0) { maxOf(2.0, 1.0) } + expect(126.0) { maxOf(58.0, 126.0) } + expect(23.0) { maxOf(Random.nextDouble(Double.MIN_VALUE, 23.0), 23.0) } + expect(Double.MAX_VALUE) { maxOf(Double.MIN_VALUE, Double.MAX_VALUE) } + expect(Double.MIN_VALUE) { maxOf(Double.MIN_VALUE, Double.MIN_VALUE) } + assertEquals(0.0, maxOf(0.0, -0.0)) + assertEquals(0.0, maxOf(-0.0, 0.0)) + assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY)) + + } + + @Test + fun maxOf_2_Float() { + expect(2.0f) { maxOf(2.0f, 1.0f) } + expect(126.0f) { maxOf(58.0f, 126.0f) } + expect(23.0f) { maxOf(Random.nextDouble(Float.MIN_VALUE.toDouble(), 23.0).toFloat(), 23.0f) } + expect(Float.MAX_VALUE) { maxOf(Float.MIN_VALUE, Float.MAX_VALUE) } + expect(Float.MIN_VALUE) { maxOf(Float.MIN_VALUE, Float.MIN_VALUE) } + assertEquals(0.0f, maxOf(0.0f, -0.0f)) + assertEquals(0.0f, maxOf(-0.0f, 0.0f)) + assertEquals(Float.POSITIVE_INFINITY, maxOf(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY)) + + } + + @Test + fun maxOf_3_Generic() { + expect(3) { maxOf<Int>(2, 1, 3) } + expect(126) { maxOf<Int>(58, 126, 55) } + expect(23) { maxOf<Int>(Random.nextInt(Int.MIN_VALUE, 23), 23, Random.nextInt(Int.MIN_VALUE, 23)) } + expect(Int.MIN_VALUE) { maxOf<Int>(Int.MIN_VALUE, Int.MIN_VALUE, Int.MIN_VALUE) } + expect(Int.MAX_VALUE) { maxOf<Int>(Int.MIN_VALUE, Int.MAX_VALUE, 0) } + + } + + @Test + fun maxOf_3_Int() { + expect(3) { maxOf(2, 1, 3) } + expect(126) { maxOf(58, 126, 55) } + expect(23) { maxOf(Random.nextInt(Int.MIN_VALUE, 23), 23, Random.nextInt(Int.MIN_VALUE, 23)) } + expect(Int.MIN_VALUE) { maxOf(Int.MIN_VALUE, Int.MIN_VALUE, Int.MIN_VALUE) } + expect(Int.MAX_VALUE) { maxOf(Int.MIN_VALUE, Int.MAX_VALUE, 0) } + + } + + @Test + fun maxOf_3_Long() { + expect(3L) { maxOf(2L, 1L, 3L) } + expect(126L) { maxOf(58L, 126L, 55L) } + expect(23L) { maxOf(Random.nextLong(Long.MIN_VALUE, 23L), 23L, Random.nextLong(Long.MIN_VALUE, 23L)) } + expect(Long.MIN_VALUE) { maxOf(Long.MIN_VALUE, Long.MIN_VALUE, Long.MIN_VALUE) } + expect(Long.MAX_VALUE) { maxOf(Long.MIN_VALUE, Long.MAX_VALUE, 0L) } + + } + + @Test + fun maxOf_3_Byte() { + expect(3.toByte()) { maxOf(2.toByte(), 1.toByte(), 3.toByte()) } + expect(126.toByte()) { maxOf(58.toByte(), 126.toByte(), 55.toByte()) } + expect(23.toByte()) { maxOf(Random.nextInt(Byte.MIN_VALUE.toInt(), 23).toByte(), 23.toByte(), Random.nextInt(Byte.MIN_VALUE.toInt(), 23).toByte()) } + expect(Byte.MIN_VALUE) { maxOf(Byte.MIN_VALUE, Byte.MIN_VALUE, Byte.MIN_VALUE) } + expect(Byte.MAX_VALUE) { maxOf(Byte.MIN_VALUE, Byte.MAX_VALUE, 0.toByte()) } + + } + + @Test + fun maxOf_3_Short() { + expect(3.toShort()) { maxOf(2.toShort(), 1.toShort(), 3.toShort()) } + expect(126.toShort()) { maxOf(58.toShort(), 126.toShort(), 55.toShort()) } + expect(23.toShort()) { maxOf(Random.nextInt(Short.MIN_VALUE.toInt(), 23).toShort(), 23.toShort(), Random.nextInt(Short.MIN_VALUE.toInt(), 23).toShort()) } + expect(Short.MIN_VALUE) { maxOf(Short.MIN_VALUE, Short.MIN_VALUE, Short.MIN_VALUE) } + expect(Short.MAX_VALUE) { maxOf(Short.MIN_VALUE, Short.MAX_VALUE, 0.toShort()) } + + } + + @Test + fun maxOf_3_Double() { + expect(3.0) { maxOf(2.0, 1.0, 3.0) } + expect(126.0) { maxOf(58.0, 126.0, 55.0) } + expect(23.0) { maxOf(Random.nextDouble(Double.MIN_VALUE, 23.0), 23.0, Random.nextDouble(Double.MIN_VALUE, 23.0)) } + expect(Double.MIN_VALUE) { maxOf(Double.MIN_VALUE, Double.MIN_VALUE, Double.MIN_VALUE) } + expect(Double.MAX_VALUE) { maxOf(Double.MIN_VALUE, Double.MAX_VALUE, 0.0) } + assertEquals(0.0, maxOf(0.0, -0.0, -0.0)) + assertEquals(0.0, maxOf(-0.0, 0.0, 0.0)) + assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) + + } + + @Test + fun maxOf_3_Float() { + expect(3.0f) { maxOf(2.0f, 1.0f, 3.0f) } + expect(126.0f) { maxOf(58.0f, 126.0f, 55.0f) } + expect(23.0f) { maxOf(Random.nextDouble(Float.MIN_VALUE.toDouble(), 23.0).toFloat(), 23.0f, Random.nextDouble(Float.MIN_VALUE.toDouble(), 23.0).toFloat()) } + expect(Float.MIN_VALUE) { maxOf(Float.MIN_VALUE, Float.MIN_VALUE, Float.MIN_VALUE) } + expect(Float.MAX_VALUE) { maxOf(Float.MIN_VALUE, Float.MAX_VALUE, 0.0f) } + assertEquals(0.0f, maxOf(0.0f, -0.0f, -0.0f)) + assertEquals(0.0f, maxOf(-0.0f, 0.0f, 0.0f)) + assertEquals(Float.POSITIVE_INFINITY, maxOf(Float.POSITIVE_INFINITY, Float.MAX_VALUE, Float.MIN_VALUE)) + + } + + @Test + fun maxOf_vararg_Generic() { + expect(10) { maxOf<Int>(2, 1, 3, 10) } + expect(126) { maxOf<Int>(58, 126, 55, 87) } + expect(23) { maxOf<Int>(Random.nextInt(Int.MIN_VALUE, 23), 23, Random.nextInt(Int.MIN_VALUE, 23), 21) } + expect(Int.MIN_VALUE) { maxOf<Int>(Int.MIN_VALUE, Int.MIN_VALUE, Int.MIN_VALUE, Int.MIN_VALUE) } + expect(Int.MAX_VALUE) { maxOf<Int>(Int.MIN_VALUE, Int.MAX_VALUE, 0, 1) } + + } + + @Test + fun maxOf_vararg_Int() { + expect(10) { maxOf(2, 1, 3, 10) } + expect(126) { maxOf(58, 126, 55, 87) } + expect(23) { maxOf(Random.nextInt(Int.MIN_VALUE, 23), 23, Random.nextInt(Int.MIN_VALUE, 23), 21) } + expect(Int.MIN_VALUE) { maxOf(Int.MIN_VALUE, Int.MIN_VALUE, Int.MIN_VALUE, Int.MIN_VALUE) } + expect(Int.MAX_VALUE) { maxOf(Int.MIN_VALUE, Int.MAX_VALUE, 0, 1) } + + } + + @Test + fun maxOf_vararg_Long() { + expect(10L) { maxOf(2L, 1L, 3L, 10L) } + expect(126L) { maxOf(58L, 126L, 55L, 87L) } + expect(23L) { maxOf(Random.nextLong(Long.MIN_VALUE, 23L), 23L, Random.nextLong(Long.MIN_VALUE, 23L), 21L) } + expect(Long.MIN_VALUE) { maxOf(Long.MIN_VALUE, Long.MIN_VALUE, Long.MIN_VALUE, Long.MIN_VALUE) } + expect(Long.MAX_VALUE) { maxOf(Long.MIN_VALUE, Long.MAX_VALUE, 0L, 1L) } + + } + + @Test + fun maxOf_vararg_Byte() { + expect(10.toByte()) { maxOf(2.toByte(), 1.toByte(), 3.toByte(), 10.toByte()) } + expect(126.toByte()) { maxOf(58.toByte(), 126.toByte(), 55.toByte(), 87.toByte()) } + expect(23.toByte()) { maxOf(Random.nextInt(Byte.MIN_VALUE.toInt(), 23).toByte(), 23.toByte(), Random.nextInt(Byte.MIN_VALUE.toInt(), 23).toByte(), 21.toByte()) } + expect(Byte.MIN_VALUE) { maxOf(Byte.MIN_VALUE, Byte.MIN_VALUE, Byte.MIN_VALUE, Byte.MIN_VALUE) } + expect(Byte.MAX_VALUE) { maxOf(Byte.MIN_VALUE, Byte.MAX_VALUE, 0.toByte(), 1.toByte()) } + + } + + @Test + fun maxOf_vararg_Short() { + expect(10.toShort()) { maxOf(2.toShort(), 1.toShort(), 3.toShort(), 10.toShort()) } + expect(126.toShort()) { maxOf(58.toShort(), 126.toShort(), 55.toShort(), 87.toShort()) } + expect(23.toShort()) { maxOf(Random.nextInt(Short.MIN_VALUE.toInt(), 23).toShort(), 23.toShort(), Random.nextInt(Short.MIN_VALUE.toInt(), 23).toShort(), 21.toShort()) } + expect(Short.MIN_VALUE) { maxOf(Short.MIN_VALUE, Short.MIN_VALUE, Short.MIN_VALUE, Short.MIN_VALUE) } + expect(Short.MAX_VALUE) { maxOf(Short.MIN_VALUE, Short.MAX_VALUE, 0.toShort(), 1.toShort()) } + + } + + @Test + fun maxOf_vararg_Double() { + expect(10.0) { maxOf(2.0, 1.0, 3.0, 10.0) } + expect(126.0) { maxOf(58.0, 126.0, 55.0, 87.0) } + expect(23.0) { maxOf(Random.nextDouble(Double.MIN_VALUE, 23.0), 23.0, Random.nextDouble(Double.MIN_VALUE, 23.0), 21.0) } + expect(Double.MIN_VALUE) { maxOf(Double.MIN_VALUE, Double.MIN_VALUE, Double.MIN_VALUE, Double.MIN_VALUE) } + expect(Double.MAX_VALUE) { maxOf(Double.MIN_VALUE, Double.MAX_VALUE, 0.0, 1.0) } + assertEquals(0.0, maxOf(0.0, -0.0, -0.0, 0.0)) + assertEquals(0.0, maxOf(-0.0, 0.0, 0.0, -0.0)) + assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) + + } + + @Test + fun maxOf_vararg_Float() { + expect(10.0f) { maxOf(2.0f, 1.0f, 3.0f, 10.0f) } + expect(126.0f) { maxOf(58.0f, 126.0f, 55.0f, 87.0f) } + expect(23.0f) { maxOf(Random.nextDouble(Float.MIN_VALUE.toDouble(), 23.0).toFloat(), 23.0f, Random.nextDouble(Float.MIN_VALUE.toDouble(), 23.0).toFloat(), 21.0f) } + expect(Float.MIN_VALUE) { maxOf(Float.MIN_VALUE, Float.MIN_VALUE, Float.MIN_VALUE, Float.MIN_VALUE) } + expect(Float.MAX_VALUE) { maxOf(Float.MIN_VALUE, Float.MAX_VALUE, 0.0f, 1.0f) } + assertEquals(0.0f, maxOf(0.0f, -0.0f, -0.0f, 0.0f)) + assertEquals(0.0f, maxOf(-0.0f, 0.0f, 0.0f, -0.0f)) + assertEquals(Float.POSITIVE_INFINITY, maxOf(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.MAX_VALUE, Float.MIN_VALUE)) + + } + + @Test + fun minOf_2_Generic() { + expect(1) { minOf<Int>(2, 1) } + expect(58) { minOf<Int>(58, 126) } + expect(23) { minOf<Int>(Random.nextInt(23..Int.MAX_VALUE), 23) } + expect(Int.MIN_VALUE) { minOf<Int>(Int.MIN_VALUE, Int.MAX_VALUE) } + expect(Int.MAX_VALUE) { minOf<Int>(Int.MAX_VALUE, Int.MAX_VALUE) } + } + + @Test + fun minOf_2_Int() { + expect(1) { minOf(2, 1) } + expect(58) { minOf(58, 126) } + expect(23) { minOf(Random.nextInt(23..Int.MAX_VALUE), 23) } + expect(Int.MIN_VALUE) { minOf(Int.MIN_VALUE, Int.MAX_VALUE) } + expect(Int.MAX_VALUE) { minOf(Int.MAX_VALUE, Int.MAX_VALUE) } + } + + @Test + fun minOf_2_Long() { + expect(1L) { minOf(2L, 1L) } + expect(58L) { minOf(58L, 126L) } + expect(23L) { minOf(Random.nextLong(23L..Long.MAX_VALUE), 23L) } + expect(Long.MIN_VALUE) { minOf(Long.MIN_VALUE, Long.MAX_VALUE) } + expect(Long.MAX_VALUE) { minOf(Long.MAX_VALUE, Long.MAX_VALUE) } + } + + @Test + fun minOf_2_Byte() { + expect(1.toByte()) { minOf(2.toByte(), 1.toByte()) } + expect(58.toByte()) { minOf(58.toByte(), 126.toByte()) } + expect(23.toByte()) { minOf(Random.nextInt(23..Byte.MAX_VALUE.toInt()).toByte(), 23.toByte()) } + expect(Byte.MIN_VALUE) { minOf(Byte.MIN_VALUE, Byte.MAX_VALUE) } + expect(Byte.MAX_VALUE) { minOf(Byte.MAX_VALUE, Byte.MAX_VALUE) } + } + + @Test + fun minOf_2_Short() { + expect(1.toShort()) { minOf(2.toShort(), 1.toShort()) } + expect(58.toShort()) { minOf(58.toShort(), 126.toShort()) } + expect(23.toShort()) { minOf(Random.nextInt(23..Short.MAX_VALUE.toInt()).toShort(), 23.toShort()) } + expect(Short.MIN_VALUE) { minOf(Short.MIN_VALUE, Short.MAX_VALUE) } + expect(Short.MAX_VALUE) { minOf(Short.MAX_VALUE, Short.MAX_VALUE) } + } + + @Test + fun minOf_2_Double() { + expect(1.0) { minOf(2.0, 1.0) } + expect(58.0) { minOf(58.0, 126.0) } + expect(23.0) { minOf(Random.nextDouble(23.0, Double.MAX_VALUE), 23.0) } + expect(Double.MIN_VALUE) { minOf(Double.MIN_VALUE, Double.MAX_VALUE) } + expect(Double.MAX_VALUE) { minOf(Double.MAX_VALUE, Double.MAX_VALUE) } + assertEquals(-0.0, minOf(0.0, -0.0)) + assertEquals(-0.0, minOf(-0.0, 0.0)) + assertEquals(Double.NEGATIVE_INFINITY, minOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY)) + + } + + @Test + fun minOf_2_Float() { + expect(1.0f) { minOf(2.0f, 1.0f) } + expect(58.0f) { minOf(58.0f, 126.0f) } + expect(23.0f) { minOf(Random.nextDouble(23.0, Float.MAX_VALUE.toDouble()).toFloat(), 23.0f) } + expect(Float.MIN_VALUE) { minOf(Float.MIN_VALUE, Float.MAX_VALUE) } + expect(Float.MAX_VALUE) { minOf(Float.MAX_VALUE, Float.MAX_VALUE) } + assertEquals(-0.0f, minOf(0.0f, -0.0f)) + assertEquals(-0.0f, minOf(-0.0f, 0.0f)) + assertEquals(Float.NEGATIVE_INFINITY, minOf(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY)) + + } + + @Test + fun minOf_3_Generic() { + expect(1) { minOf<Int>(2, 1, 3) } + expect(55) { minOf<Int>(58, 126, 55) } + expect(23) { minOf<Int>(Random.nextInt(23..Int.MAX_VALUE), 23, Random.nextInt(23..Int.MAX_VALUE)) } + expect(Int.MAX_VALUE) { minOf<Int>(Int.MAX_VALUE, Int.MAX_VALUE, Int.MAX_VALUE) } + expect(Int.MIN_VALUE) { minOf<Int>(Int.MIN_VALUE, Int.MAX_VALUE, 0) } + + } + + @Test + fun minOf_3_Int() { + expect(1) { minOf(2, 1, 3) } + expect(55) { minOf(58, 126, 55) } + expect(23) { minOf(Random.nextInt(23..Int.MAX_VALUE), 23, Random.nextInt(23..Int.MAX_VALUE)) } + expect(Int.MAX_VALUE) { minOf(Int.MAX_VALUE, Int.MAX_VALUE, Int.MAX_VALUE) } + expect(Int.MIN_VALUE) { minOf(Int.MIN_VALUE, Int.MAX_VALUE, 0) } + + } + + @Test + fun minOf_3_Long() { + expect(1L) { minOf(2L, 1L, 3L) } + expect(55L) { minOf(58L, 126L, 55L) } + expect(23L) { minOf(Random.nextLong(23L..Long.MAX_VALUE), 23L, Random.nextLong(23L..Long.MAX_VALUE)) } + expect(Long.MAX_VALUE) { minOf(Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE) } + expect(Long.MIN_VALUE) { minOf(Long.MIN_VALUE, Long.MAX_VALUE, 0L) } + + } + + @Test + fun minOf_3_Byte() { + expect(1.toByte()) { minOf(2.toByte(), 1.toByte(), 3.toByte()) } + expect(55.toByte()) { minOf(58.toByte(), 126.toByte(), 55.toByte()) } + expect(23.toByte()) { minOf(Random.nextInt(23..Byte.MAX_VALUE.toInt()).toByte(), 23.toByte(), Random.nextInt(23..Byte.MAX_VALUE.toInt()).toByte()) } + expect(Byte.MAX_VALUE) { minOf(Byte.MAX_VALUE, Byte.MAX_VALUE, Byte.MAX_VALUE) } + expect(Byte.MIN_VALUE) { minOf(Byte.MIN_VALUE, Byte.MAX_VALUE, 0) } + + } + + @Test + fun minOf_3_Short() { + expect(1.toShort()) { minOf(2.toShort(), 1.toShort(), 3.toShort()) } + expect(55.toShort()) { minOf(58.toShort(), 126.toShort(), 55.toShort()) } + expect(23.toShort()) { minOf(Random.nextInt(23..Short.MAX_VALUE.toInt()).toShort(), 23.toShort(), Random.nextInt(23..Short.MAX_VALUE.toInt()).toShort()) } + expect(Short.MAX_VALUE) { minOf(Short.MAX_VALUE, Short.MAX_VALUE, Short.MAX_VALUE) } + expect(Short.MIN_VALUE) { minOf(Short.MIN_VALUE, Short.MAX_VALUE, 0) } + + } + + @Test + fun minOf_3_Double() { + expect(1.0) { minOf(2.0, 1.0, 3.0) } + expect(55.0) { minOf(58.0, 126.0, 55.0) } + expect(23.0) { minOf(Random.nextDouble(23.0, Double.MAX_VALUE), 23.0, Random.nextDouble(23.0, Double.MAX_VALUE)) } + expect(Double.MAX_VALUE) { minOf(Double.MAX_VALUE, Double.MAX_VALUE, Double.MAX_VALUE) } + expect(0.0) { minOf(Double.MIN_VALUE, Double.MAX_VALUE, 0.0) } + assertEquals(-0.0, minOf(0.0, -0.0, -0.0)) + assertEquals(-0.0, minOf(-0.0, 0.0, 0.0)) + assertEquals(Double.MIN_VALUE, minOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) + + } + + @Test + fun minOf_3_Float() { + expect(1.0f) { minOf(2.0f, 1.0f, 3.0f) } + expect(55.0f) { minOf(58.0f, 126.0f, 55.0f) } + expect(23.0f) { minOf(Random.nextDouble(23.0, Float.MAX_VALUE.toDouble()).toFloat(), 23.0f, Random.nextDouble(23.0, Float.MAX_VALUE.toDouble()).toFloat()) } + expect(Float.MAX_VALUE) { minOf(Float.MAX_VALUE, Float.MAX_VALUE, Float.MAX_VALUE) } + expect(0.0f) { minOf(Float.MIN_VALUE, Float.MAX_VALUE, 0.0f) } + assertEquals(-0.0f, minOf(0.0f, -0.0f, -0.0f)) + assertEquals(-0.0f, minOf(-0.0f, 0.0f, 0.0f)) + assertEquals(Float.MIN_VALUE, minOf(Float.POSITIVE_INFINITY, Float.MAX_VALUE, Float.MIN_VALUE)) + + } + + @Test + fun minOf_vararg_Generic() { + expect(1) { minOf<Int>(2, 1, 3, 10) } + expect(55) { minOf<Int>(58, 126, 55, 87) } + expect(21) { minOf<Int>(Random.nextInt(23..Int.MAX_VALUE), 23, Random.nextInt(23..Int.MAX_VALUE), 21) } + expect(Int.MAX_VALUE) { minOf<Int>(Int.MAX_VALUE, Int.MAX_VALUE, Int.MAX_VALUE, Int.MAX_VALUE) } + assertEquals(Int.MIN_VALUE, minOf<Int>(Int.MIN_VALUE, Int.MAX_VALUE, 0, 1)) + + } + + @Test + fun minOf_vararg_Int() { + expect(1) { minOf(2, 1, 3, 10) } + expect(55) { minOf(58, 126, 55, 87) } + expect(21) { minOf(Random.nextInt(23..Int.MAX_VALUE), 23, Random.nextInt(23..Int.MAX_VALUE), 21) } + expect(Int.MAX_VALUE) { minOf(Int.MAX_VALUE, Int.MAX_VALUE, Int.MAX_VALUE, Int.MAX_VALUE) } + assertEquals(Int.MIN_VALUE, minOf(Int.MIN_VALUE, Int.MAX_VALUE, 0, 1)) + + } + + @Test + fun minOf_vararg_Long() { + expect(1L) { minOf(2L, 1L, 3L, 10L) } + expect(55L) { minOf(58L, 126L, 55L, 87L) } + expect(21L) { minOf(Random.nextLong(23L..Long.MAX_VALUE), 23L, Random.nextLong(23L..Long.MAX_VALUE), 21L) } + expect(Long.MAX_VALUE) { minOf(Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE, Long.MAX_VALUE) } + assertEquals(Long.MIN_VALUE, minOf(Long.MIN_VALUE, Long.MAX_VALUE, 0L, 1L)) + + } + + @Test + fun minOf_vararg_Byte() { + expect(1.toByte()) { minOf(2.toByte(), 1.toByte(), 3.toByte(), 10.toByte()) } + expect(55.toByte()) { minOf(58.toByte(), 126.toByte(), 55.toByte(), 87.toByte()) } + expect(21.toByte()) { minOf(Random.nextInt(23..Byte.MAX_VALUE.toInt()).toByte(), 23.toByte(), Random.nextInt(23..Byte.MAX_VALUE.toInt()).toByte(), 21.toByte()) } + expect(Byte.MAX_VALUE) { minOf(Byte.MAX_VALUE, Byte.MAX_VALUE, Byte.MAX_VALUE, Byte.MAX_VALUE) } + assertEquals(Byte.MIN_VALUE, minOf(Byte.MIN_VALUE, Byte.MAX_VALUE, 0.toByte(), 1.toByte())) + + } + + @Test + fun minOf_vararg_Short() { + expect(1.toShort()) { minOf(2.toShort(), 1.toShort(), 3.toShort(), 10.toShort()) } + expect(55.toShort()) { minOf(58.toShort(), 126.toShort(), 55.toShort(), 87.toShort()) } + expect(21.toShort()) { minOf(Random.nextInt(23..Short.MAX_VALUE.toInt()).toShort(), 23.toShort(), Random.nextInt(23..Short.MAX_VALUE.toInt()).toShort(), 21.toShort()) } + expect(Short.MAX_VALUE) { minOf(Short.MAX_VALUE, Short.MAX_VALUE, Short.MAX_VALUE, Short.MAX_VALUE) } + assertEquals(Short.MIN_VALUE, minOf(Short.MIN_VALUE, Short.MAX_VALUE, 0.toShort(), 1.toShort())) + + } + + @Test + fun minOf_vararg_Double() { + expect(1.0) { minOf(2.0, 1.0, 3.0, 10.0) } + expect(55.0) { minOf(58.0, 126.0, 55.0, 87.0) } + expect(21.0) { minOf(Random.nextDouble(23.0, Double.MAX_VALUE), 23.0, Random.nextDouble(23.0, Double.MAX_VALUE), 21.0) } + expect(Double.MAX_VALUE) { minOf(Double.MAX_VALUE, Double.MAX_VALUE, Double.MAX_VALUE, Double.MAX_VALUE) } + assertEquals(0.0, minOf(Double.MIN_VALUE, Double.MAX_VALUE, 0.0, 1.0)) + assertEquals(-0.0, minOf(0.0, -0.0, -0.0, 0.0)) + assertEquals(-0.0, minOf(-0.0, 0.0, 0.0, -0.0)) + assertEquals(Double.NEGATIVE_INFINITY, minOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE)) + + } + + @Test + fun minOf_vararg_Float() { + expect(1.0f) { minOf(2.0f, 1.0f, 3.0f, 10.0f) } + expect(55.0f) { minOf(58.0f, 126.0f, 55.0f, 87.0f) } + expect(21.0f) { minOf(Random.nextDouble(23.0, Float.MAX_VALUE.toDouble()).toFloat(), 23.0f, Random.nextDouble(23.0, Float.MAX_VALUE.toDouble()).toFloat(), 21.0f) } + expect(Float.MAX_VALUE) { minOf(Float.MAX_VALUE, Float.MAX_VALUE, Float.MAX_VALUE, Float.MAX_VALUE) } + assertEquals(0.0f, minOf(Float.MIN_VALUE, Float.MAX_VALUE, 0.0f, 1.0f)) + assertEquals(-0.0f, minOf(0.0f, -0.0f, -0.0f, 0.0f)) + assertEquals(-0.0f, minOf(-0.0f, 0.0f, 0.0f, -0.0f)) + assertEquals(Float.NEGATIVE_INFINITY, minOf(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.MAX_VALUE, Float.MIN_VALUE)) + + } + +}
diff --git a/libraries/stdlib/test/generated/_PrimitivesTest.kt b/libraries/stdlib/test/generated/_PrimitivesTest.kt new file mode 100644 index 0000000..7da6827 --- /dev/null +++ b/libraries/stdlib/test/generated/_PrimitivesTest.kt
@@ -0,0 +1,194 @@ +/* + * 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.numbers + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLibTests.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.random.* +import kotlin.test.* + +class _PrimitivesTest { + @Test + fun bits_Byte() { + fun test(value: Byte, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { + assertEquals(oneBits, value.countOneBits()) + assertEquals(leadingZeroes, value.countLeadingZeroBits()) + assertEquals(trailingZeroes, value.countTrailingZeroBits()) + val highestBit = if (leadingZeroes < Byte.SIZE_BITS) 1.shl(Byte.SIZE_BITS - leadingZeroes - 1).toByte() else 0 + val lowestBit = if (trailingZeroes < Byte.SIZE_BITS) 1.shl(trailingZeroes).toByte() else 0 + assertEquals(highestBit, value.takeHighestOneBit()) + assertEquals(lowestBit, value.takeLowestOneBit()) + } + test(0, 0, 8, 8) + test(1, 1, 7, 0) + test(2, 1, 6, 1) + test(0x44, 2, 1, 2) + test(0x80.toByte(), 1, 0, 7) + test(0xF0.toByte(), 4, 0, 4) + } + + @Test + fun bits_Short() { + fun test(value: Short, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { + assertEquals(oneBits, value.countOneBits()) + assertEquals(leadingZeroes, value.countLeadingZeroBits()) + assertEquals(trailingZeroes, value.countTrailingZeroBits()) + val highestBit = if (leadingZeroes < Short.SIZE_BITS) 1.shl(Short.SIZE_BITS - leadingZeroes - 1).toShort() else 0 + val lowestBit = if (trailingZeroes < Short.SIZE_BITS) 1.shl(trailingZeroes).toShort() else 0 + assertEquals(highestBit, value.takeHighestOneBit()) + assertEquals(lowestBit, value.takeLowestOneBit()) + } + test(0, 0, 16, 16) + test(1, 1, 15, 0) + test(2, 1, 14, 1) + test(0xF2, 5, 8, 1) + test(0x8000.toShort(), 1, 0, 15) + test(0xF200.toShort(), 5, 0, 9) + } + + @Test + fun bits_Int() { + fun test(value: Int, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { + assertEquals(oneBits, value.countOneBits()) + assertEquals(leadingZeroes, value.countLeadingZeroBits()) + assertEquals(trailingZeroes, value.countTrailingZeroBits()) + val highestBit = if (leadingZeroes < Int.SIZE_BITS) 1.shl(Int.SIZE_BITS - leadingZeroes - 1).toInt() else 0 + val lowestBit = if (trailingZeroes < Int.SIZE_BITS) 1.shl(trailingZeroes).toInt() else 0 + assertEquals(highestBit, value.takeHighestOneBit()) + assertEquals(lowestBit, value.takeLowestOneBit()) + } + test(0, 0, 32, 32) + test(1, 1, 31, 0) + test(2, 1, 30, 1) + test(0xF002, 5, 16, 1) + test(0xF00F0000.toInt(), 8, 0, 16) + } + + @Test + fun bits_Long() { + fun test(value: Long, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { + assertEquals(oneBits, value.countOneBits()) + assertEquals(leadingZeroes, value.countLeadingZeroBits()) + assertEquals(trailingZeroes, value.countTrailingZeroBits()) + val highestBit = if (leadingZeroes < Long.SIZE_BITS) 1L.shl(Long.SIZE_BITS - leadingZeroes - 1).toLong() else 0L + val lowestBit = if (trailingZeroes < Long.SIZE_BITS) 1L.shl(trailingZeroes).toLong() else 0L + assertEquals(highestBit, value.takeHighestOneBit()) + assertEquals(lowestBit, value.takeLowestOneBit()) + } + test(0L, 0, 64, 64) + test(1L, 1, 63, 0) + test(2L, 1, 62, 1) + test(0xF002, 5, 48, 1) + test(0xF00F0000L, 8, 32, 16) + test(0x1111_3333_EEEE_0000L, 4 + 8 + 12, 3, 17) + } + + @Test + fun rotate_Byte() { + fun test(value: Byte, n: Int, expected: Byte) { + assertEquals(expected, value.rotateLeft(n)) + assertEquals(expected, value.rotateRight(-n)) + } + fun testCyclic(value: Byte) { + for (n in -2 * Byte.SIZE_BITS..2 * Byte.SIZE_BITS) { + val rl = value.rotateLeft(n) + val rr = value.rotateRight(-n) + assertEquals(rl, rr) + assertEquals(rl, value.rotateLeft(n % Byte.SIZE_BITS)) + assertEquals(rr, value.rotateRight((-n) % Byte.SIZE_BITS)) + assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) + assertEquals(value, value.rotateRight(n).rotateRight(-n)) + } + } + test(0x73, 4, 0x37) + test(0x73, -3, 0x6E) + test(0x73, 1, 0xE6.toByte()) + test(0xE6.toByte(), 1, 0xCD.toByte()) + repeat(100) { + testCyclic(Random.nextInt().toByte()) + } + } + + @Test + fun rotate_Short() { + fun test(value: Short, n: Int, expected: Short) { + assertEquals(expected, value.rotateLeft(n)) + assertEquals(expected, value.rotateRight(-n)) + } + fun testCyclic(value: Short) { + for (n in -2 * Short.SIZE_BITS..2 * Short.SIZE_BITS) { + val rl = value.rotateLeft(n) + val rr = value.rotateRight(-n) + assertEquals(rl, rr) + assertEquals(rl, value.rotateLeft(n % Short.SIZE_BITS)) + assertEquals(rr, value.rotateRight((-n) % Short.SIZE_BITS)) + assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) + assertEquals(value, value.rotateRight(n).rotateRight(-n)) + } + } + test(0x7361, 4, 0x3617) + test(0x7361, -3, 0b001_0111_0011_0110_0) + test(0x7361, 1, 0b111_0011_0110_0001_0.toShort()) + test(0xE6C2.toShort(), 1, 0b11_0011_0110_0001_01.toShort()) + repeat(100) { + testCyclic(Random.nextInt().toShort()) + } + } + + @Test + fun rotate_Int() { + fun test(value: Int, n: Int, expected: Int) { + assertEquals(expected, value.rotateLeft(n)) + assertEquals(expected, value.rotateRight(-n)) + } + fun testCyclic(value: Int) { + for (n in -2 * Int.SIZE_BITS..2 * Int.SIZE_BITS) { + val rl = value.rotateLeft(n) + val rr = value.rotateRight(-n) + assertEquals(rl, rr) + assertEquals(rl, value.rotateLeft(n % Int.SIZE_BITS)) + assertEquals(rr, value.rotateRight((-n) % Int.SIZE_BITS)) + assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) + assertEquals(value, value.rotateRight(n).rotateRight(-n)) + } + } + test(0x7_3422345, 4, 0x3422345_7) + test(0x7342234_5, -4, 0x5_7342234) + test(0x73422345, 1, 0xE684468A.toInt()) + repeat(100) { + testCyclic(Random.nextInt()) + } + } + + @Test + fun rotate_Long() { + fun test(value: Long, n: Int, expected: Long) { + assertEquals(expected, value.rotateLeft(n)) + assertEquals(expected, value.rotateRight(-n)) + } + fun testCyclic(value: Long) { + for (n in -2 * Long.SIZE_BITS..2 * Long.SIZE_BITS) { + val rl = value.rotateLeft(n) + val rr = value.rotateRight(-n) + assertEquals(rl, rr) + assertEquals(rl, value.rotateLeft(n % Long.SIZE_BITS)) + assertEquals(rr, value.rotateRight((-n) % Long.SIZE_BITS)) + assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) + assertEquals(value, value.rotateRight(n).rotateRight(-n)) + } + } + test(0x7372ABAC_DEEF0123, 4, 0x372ABAC_DEEF01237) + test(0x88888888_44444444U.toLong(), -3, 0x91111111_08888888u.toLong()) + test(0x88888888_44444444U.toLong(), 1, 0x11111110_88888889) + repeat(100) { + testCyclic(Random.nextLong()) + } + } + +}
diff --git a/libraries/stdlib/test/generated/_SequencesTest.kt b/libraries/stdlib/test/generated/_SequencesTest.kt new file mode 100644 index 0000000..bd93b32 --- /dev/null +++ b/libraries/stdlib/test/generated/_SequencesTest.kt
@@ -0,0 +1,123 @@ +/* + * 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.sequences + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLibTests.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import test.comparisons.STRING_CASE_INSENSITIVE_ORDER +import test.collections.assertSorted +import kotlin.test.* + +class _SequencesTest { + @Test + fun foldIndexed_Sequence() { + expect(8) { sequenceOf<Int>(1, 2, 3).foldIndexed(0) { i, acc, e -> acc + i.toInt() * e } } + expect(10) { sequenceOf<Int>(1, 2, 3).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15) { sequenceOf<Int>(1, 2, 3).foldIndexed(1) { i, acc, e -> acc * (i.toInt() + e) } } + expect(" 0-1 1-2 2-3") { sequenceOf<Int>(1, 2, 3).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42) { + val numbers = sequenceOf<Int>(1, 2, 3, 4) + numbers.foldIndexed(0) { index, a, b -> index.toInt() * (a + b) } + } + expect(0) { + val numbers = sequenceOf<Int>() + numbers.foldIndexed(0) { index, a, b -> index.toInt() * (a + b) } + } + expect("11234") { + val numbers = sequenceOf<Int>(1, 2, 3, 4) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun maxByOrNull_Sequence() { + assertEquals(null, sequenceOf<Int>().maxByOrNull { it }) + assertEquals(1, sequenceOf<Int>(1).maxByOrNull { it }) + assertEquals(3, sequenceOf<Int>(3, 2).maxByOrNull { it * it }) + assertEquals(3, sequenceOf<Int>(3, 2).maxByOrNull { "a" }) + assertEquals(3, sequenceOf<Int>(3, 2).maxByOrNull { it.toString() }) + assertEquals(2, sequenceOf<Int>(2, 3).maxByOrNull { -it }) + assertEquals('b', sequenceOf('a', 'b').maxByOrNull { "x$it" }) + assertEquals("abc", sequenceOf("b", "abc").maxByOrNull { it.length }) + } + + @Test + fun maxWithOrNull_Sequence() { + assertEquals(null, sequenceOf<Int>().maxWithOrNull(naturalOrder())) + assertEquals(1, sequenceOf<Int>(1).maxWithOrNull(naturalOrder())) + assertEquals(3, sequenceOf<Int>(2, 3, 4).maxWithOrNull(compareBy { it % 4 })) + assertEquals("B", sequenceOf("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) + } + + @Test + fun minByOrNull_Sequence() { + assertEquals(null, sequenceOf<Int>().minByOrNull { it }) + assertEquals(1, sequenceOf<Int>(1).minByOrNull { it }) + assertEquals(2, sequenceOf<Int>(3, 2).minByOrNull { it * it }) + assertEquals(3, sequenceOf<Int>(3, 2).minByOrNull { "a" }) + assertEquals(2, sequenceOf<Int>(3, 2).minByOrNull { it.toString() }) + assertEquals(3, sequenceOf<Int>(2, 3).minByOrNull { -it }) + assertEquals('a', sequenceOf('a', 'b').minByOrNull { "x$it" }) + assertEquals("b", sequenceOf("b", "abc").minByOrNull { it.length }) + } + + @Test + fun minWithOrNull_Sequence() { + assertEquals(null, sequenceOf<Int>().minWithOrNull(naturalOrder())) + assertEquals(1, sequenceOf<Int>(1).minWithOrNull(naturalOrder())) + assertEquals(4, sequenceOf<Int>(2, 3, 4).minWithOrNull(compareBy { it % 4 })) + assertEquals("a", sequenceOf("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) + } + + @Test + fun indexOf_Sequence() { + expect(-1) { sequenceOf<Int>(1, 2, 3).indexOf(0) } + expect(0) { sequenceOf<Int>(1, 2, 3).indexOf(1) } + expect(1) { sequenceOf<Int>(1, 2, 3).indexOf(2) } + expect(2) { sequenceOf<Int>(1, 2, 3).indexOf(3) } + expect(-1) { sequenceOf("cat", "dog", "bird").indexOf("mouse") } + expect(0) { sequenceOf("cat", "dog", "bird").indexOf("cat") } + expect(1) { sequenceOf("cat", "dog", "bird").indexOf("dog") } + expect(2) { sequenceOf("cat", "dog", "bird").indexOf("bird") } + expect(0) { sequenceOf(null, "dog", null).indexOf(null as String?)} + } + + @Test + fun indexOfFirst_Sequence() { + expect(-1) { sequenceOf<Int>(1, 2, 3).indexOfFirst { it == 0 } } + expect(0) { sequenceOf<Int>(1, 2, 3).indexOfFirst { it % 2 == 1 } } + expect(1) { sequenceOf<Int>(1, 2, 3).indexOfFirst { it % 2 == 0 } } + expect(2) { sequenceOf<Int>(1, 2, 3).indexOfFirst { it == 3 } } + expect(-1) { sequenceOf("cat", "dog", "bird").indexOfFirst { it.contains("p") } } + expect(0) { sequenceOf("cat", "dog", "bird").indexOfFirst { it.startsWith('c') } } + expect(1) { sequenceOf("cat", "dog", "bird").indexOfFirst { it.startsWith('d') } } + expect(2) { sequenceOf("cat", "dog", "bird").indexOfFirst { it.endsWith('d') } } + } + + @Test + fun sorted_Sequence() { + sequenceOf<Int>(3, 7, 1).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + sequenceOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + sequenceOf("ac", "aD", "aba").sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedDescending_Sequence() { + sequenceOf<Int>(3, 7, 1).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + sequenceOf(1, Int.MAX_VALUE, Int.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + sequenceOf("ac", "aD", "aba").sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedWith_Sequence() { + val comparator = compareBy { it: Int -> it % 3 }.thenByDescending { it } + sequenceOf<Int>(0, 1, 2, 3, 4, 5).sortedWith(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 } + } + +}
diff --git a/libraries/stdlib/test/generated/_UArraysTest.kt b/libraries/stdlib/test/generated/_UArraysTest.kt new file mode 100644 index 0000000..d95c415 --- /dev/null +++ b/libraries/stdlib/test/generated/_UArraysTest.kt
@@ -0,0 +1,842 @@ +/* + * 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 + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLibTests.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.random.* +import test.assertArrayContentEquals +import kotlin.test.* + +class _UArraysTest { + @Test + fun foldIndexed_UIntArray() { + expect(8u) { uintArrayOf(1u, 2u, 3u).foldIndexed(0u) { i, acc, e -> acc + i.toUInt() * e } } + expect(10) { uintArrayOf(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") { uintArrayOf(1u, 2u, 3u).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42u) { + val numbers = uintArrayOf(1u, 2u, 3u, 4u) + numbers.foldIndexed(0u) { index, a, b -> index.toUInt() * (a + b) } + } + expect(0u) { + val numbers = uintArrayOf() + numbers.foldIndexed(0u) { index, a, b -> index.toUInt() * (a + b) } + } + expect("11234") { + val numbers = uintArrayOf(1u, 2u, 3u, 4u) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldIndexed_ULongArray() { + expect(8uL) { ulongArrayOf(1uL, 2uL, 3uL).foldIndexed(0uL) { i, acc, e -> acc + i.toULong() * e } } + expect(10) { ulongArrayOf(1uL, 2uL, 3uL).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15uL) { ulongArrayOf(1uL, 2uL, 3uL).foldIndexed(1uL) { i, acc, e -> acc * (i.toULong() + e) } } + expect(" 0-1 1-2 2-3") { ulongArrayOf(1uL, 2uL, 3uL).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42uL) { + val numbers = ulongArrayOf(1uL, 2uL, 3uL, 4uL) + numbers.foldIndexed(0uL) { index, a, b -> index.toULong() * (a + b) } + } + expect(0uL) { + val numbers = ulongArrayOf() + numbers.foldIndexed(0uL) { index, a, b -> index.toULong() * (a + b) } + } + expect("11234") { + val numbers = ulongArrayOf(1uL, 2uL, 3uL, 4uL) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldIndexed_UByteArray() { + expect(8u) { ubyteArrayOf(1u, 2u, 3u).foldIndexed(0u) { i, acc, e -> acc + i.toUByte() * e } } + expect(10) { ubyteArrayOf(1u, 2u, 3u).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15u) { ubyteArrayOf(1u, 2u, 3u).foldIndexed(1u) { i, acc, e -> acc * (i.toUByte() + e) } } + expect(" 0-1 1-2 2-3") { ubyteArrayOf(1u, 2u, 3u).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42u) { + val numbers = ubyteArrayOf(1u, 2u, 3u, 4u) + numbers.foldIndexed(0u) { index, a, b -> index.toUByte() * (a + b) } + } + expect(0u) { + val numbers = ubyteArrayOf() + numbers.foldIndexed(0u) { index, a, b -> index.toUByte() * (a + b) } + } + expect("11234") { + val numbers = ubyteArrayOf(1u, 2u, 3u, 4u) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldIndexed_UShortArray() { + expect(8u) { ushortArrayOf(1u, 2u, 3u).foldIndexed(0u) { i, acc, e -> acc + i.toUShort() * e } } + expect(10) { ushortArrayOf(1u, 2u, 3u).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15u) { ushortArrayOf(1u, 2u, 3u).foldIndexed(1u) { i, acc, e -> acc * (i.toUShort() + e) } } + expect(" 0-1 1-2 2-3") { ushortArrayOf(1u, 2u, 3u).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(42u) { + val numbers = ushortArrayOf(1u, 2u, 3u, 4u) + numbers.foldIndexed(0u) { index, a, b -> index.toUShort() * (a + b) } + } + expect(0u) { + val numbers = ushortArrayOf() + numbers.foldIndexed(0u) { index, a, b -> index.toUShort() * (a + b) } + } + expect("11234") { + val numbers = ushortArrayOf(1u, 2u, 3u, 4u) + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + } + + @Test + fun foldRightIndexed_UIntArray() { + expect(8u) { uintArrayOf(1u, 2u, 3u).foldRightIndexed(0u) { i, e, acc -> acc + i.toUInt() * e } } + expect(10) { uintArrayOf(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") { uintArrayOf(1u, 2u, 3u).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = uintArrayOf(1u, 2u, 3u, 4u) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun foldRightIndexed_ULongArray() { + expect(8uL) { ulongArrayOf(1uL, 2uL, 3uL).foldRightIndexed(0uL) { i, e, acc -> acc + i.toULong() * e } } + expect(10) { ulongArrayOf(1uL, 2uL, 3uL).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15uL) { ulongArrayOf(1uL, 2uL, 3uL).foldRightIndexed(1uL) { i, e, acc -> acc * (i.toULong() + e) } } + expect(" 2-3 1-2 0-1") { ulongArrayOf(1uL, 2uL, 3uL).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = ulongArrayOf(1uL, 2uL, 3uL, 4uL) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun foldRightIndexed_UByteArray() { + expect(8u) { ubyteArrayOf(1u, 2u, 3u).foldRightIndexed(0u) { i, e, acc -> acc + i.toUByte() * e } } + expect(10) { ubyteArrayOf(1u, 2u, 3u).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15u) { ubyteArrayOf(1u, 2u, 3u).foldRightIndexed(1u) { i, e, acc -> acc * (i.toUByte() + e) } } + expect(" 2-3 1-2 0-1") { ubyteArrayOf(1u, 2u, 3u).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = ubyteArrayOf(1u, 2u, 3u, 4u) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun foldRightIndexed_UShortArray() { + expect(8u) { ushortArrayOf(1u, 2u, 3u).foldRightIndexed(0u) { i, e, acc -> acc + i.toUShort() * e } } + expect(10) { ushortArrayOf(1u, 2u, 3u).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15u) { ushortArrayOf(1u, 2u, 3u).foldRightIndexed(1u) { i, e, acc -> acc * (i.toUShort() + e) } } + expect(" 2-3 1-2 0-1") { ushortArrayOf(1u, 2u, 3u).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect("12343210") { + val numbers = ushortArrayOf(1u, 2u, 3u, 4u) + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + } + + @Test + fun maxByOrNull_UIntArray() { + assertEquals(null, uintArrayOf().maxByOrNull { it }) + assertEquals(1u, uintArrayOf(1u).maxByOrNull { it }) + assertEquals(3u, uintArrayOf(3u, 2u).maxByOrNull { it * it }) + assertEquals(3u, uintArrayOf(3u, 2u).maxByOrNull { "a" }) + assertEquals(3u, uintArrayOf(3u, 2u).maxByOrNull { it.toString() }) + } + + @Test + fun maxByOrNull_ULongArray() { + assertEquals(null, ulongArrayOf().maxByOrNull { it }) + assertEquals(1uL, ulongArrayOf(1uL).maxByOrNull { it }) + assertEquals(3uL, ulongArrayOf(3uL, 2uL).maxByOrNull { it * it }) + assertEquals(3uL, ulongArrayOf(3uL, 2uL).maxByOrNull { "a" }) + assertEquals(3uL, ulongArrayOf(3uL, 2uL).maxByOrNull { it.toString() }) + } + + @Test + fun maxByOrNull_UByteArray() { + assertEquals(null, ubyteArrayOf().maxByOrNull { it }) + assertEquals(1u, ubyteArrayOf(1u).maxByOrNull { it }) + assertEquals(3u, ubyteArrayOf(3u, 2u).maxByOrNull { it * it }) + assertEquals(3u, ubyteArrayOf(3u, 2u).maxByOrNull { "a" }) + assertEquals(3u, ubyteArrayOf(3u, 2u).maxByOrNull { it.toString() }) + } + + @Test + fun maxByOrNull_UShortArray() { + assertEquals(null, ushortArrayOf().maxByOrNull { it }) + assertEquals(1u, ushortArrayOf(1u).maxByOrNull { it }) + assertEquals(3u, ushortArrayOf(3u, 2u).maxByOrNull { it * it }) + assertEquals(3u, ushortArrayOf(3u, 2u).maxByOrNull { "a" }) + assertEquals(3u, ushortArrayOf(3u, 2u).maxByOrNull { it.toString() }) + } + + @Test + fun maxWithOrNull_UIntArray() { + assertEquals(null, uintArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1u, uintArrayOf(1u).maxWithOrNull(naturalOrder())) + assertEquals(3u, uintArrayOf(2u, 3u, 4u).maxWithOrNull(compareBy { it % 4u })) + } + + @Test + fun maxWithOrNull_ULongArray() { + assertEquals(null, ulongArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1uL, ulongArrayOf(1uL).maxWithOrNull(naturalOrder())) + assertEquals(3uL, ulongArrayOf(2uL, 3uL, 4uL).maxWithOrNull(compareBy { it % 4uL })) + } + + @Test + fun maxWithOrNull_UByteArray() { + assertEquals(null, ubyteArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1u, ubyteArrayOf(1u).maxWithOrNull(naturalOrder())) + assertEquals(3u, ubyteArrayOf(2u, 3u, 4u).maxWithOrNull(compareBy { it % 4u })) + } + + @Test + fun maxWithOrNull_UShortArray() { + assertEquals(null, ushortArrayOf().maxWithOrNull(naturalOrder())) + assertEquals(1u, ushortArrayOf(1u).maxWithOrNull(naturalOrder())) + assertEquals(3u, ushortArrayOf(2u, 3u, 4u).maxWithOrNull(compareBy { it % 4u })) + } + + @Test + fun minByOrNull_UIntArray() { + assertEquals(null, uintArrayOf().minByOrNull { it }) + assertEquals(1u, uintArrayOf(1u).minByOrNull { it }) + assertEquals(2u, uintArrayOf(3u, 2u).minByOrNull { it * it }) + assertEquals(3u, uintArrayOf(3u, 2u).minByOrNull { "a" }) + assertEquals(2u, uintArrayOf(3u, 2u).minByOrNull { it.toString() }) + } + + @Test + fun minByOrNull_ULongArray() { + assertEquals(null, ulongArrayOf().minByOrNull { it }) + assertEquals(1uL, ulongArrayOf(1uL).minByOrNull { it }) + assertEquals(2uL, ulongArrayOf(3uL, 2uL).minByOrNull { it * it }) + assertEquals(3uL, ulongArrayOf(3uL, 2uL).minByOrNull { "a" }) + assertEquals(2uL, ulongArrayOf(3uL, 2uL).minByOrNull { it.toString() }) + } + + @Test + fun minByOrNull_UByteArray() { + assertEquals(null, ubyteArrayOf().minByOrNull { it }) + assertEquals(1u, ubyteArrayOf(1u).minByOrNull { it }) + assertEquals(2u, ubyteArrayOf(3u, 2u).minByOrNull { it * it }) + assertEquals(3u, ubyteArrayOf(3u, 2u).minByOrNull { "a" }) + assertEquals(2u, ubyteArrayOf(3u, 2u).minByOrNull { it.toString() }) + } + + @Test + fun minByOrNull_UShortArray() { + assertEquals(null, ushortArrayOf().minByOrNull { it }) + assertEquals(1u, ushortArrayOf(1u).minByOrNull { it }) + assertEquals(2u, ushortArrayOf(3u, 2u).minByOrNull { it * it }) + assertEquals(3u, ushortArrayOf(3u, 2u).minByOrNull { "a" }) + assertEquals(2u, ushortArrayOf(3u, 2u).minByOrNull { it.toString() }) + } + + @Test + fun minWithOrNull_UIntArray() { + assertEquals(null, uintArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1u, uintArrayOf(1u).minWithOrNull(naturalOrder())) + assertEquals(4u, uintArrayOf(2u, 3u, 4u).minWithOrNull(compareBy { it % 4u })) + } + + @Test + fun minWithOrNull_ULongArray() { + assertEquals(null, ulongArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1uL, ulongArrayOf(1uL).minWithOrNull(naturalOrder())) + assertEquals(4uL, ulongArrayOf(2uL, 3uL, 4uL).minWithOrNull(compareBy { it % 4uL })) + } + + @Test + fun minWithOrNull_UByteArray() { + assertEquals(null, ubyteArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1u, ubyteArrayOf(1u).minWithOrNull(naturalOrder())) + assertEquals(4u, ubyteArrayOf(2u, 3u, 4u).minWithOrNull(compareBy { it % 4u })) + } + + @Test + fun minWithOrNull_UShortArray() { + assertEquals(null, ushortArrayOf().minWithOrNull(naturalOrder())) + assertEquals(1u, ushortArrayOf(1u).minWithOrNull(naturalOrder())) + assertEquals(4u, ushortArrayOf(2u, 3u, 4u).minWithOrNull(compareBy { it % 4u })) + } + + @Test + fun indexOf_UIntArray() { + expect(-1) { uintArrayOf(1u, 2u, 3u).indexOf(0u) } + expect(0) { uintArrayOf(1u, 2u, 3u).indexOf(1u) } + expect(1) { uintArrayOf(1u, 2u, 3u).indexOf(2u) } + expect(2) { uintArrayOf(1u, 2u, 3u).indexOf(3u) } + } + + @Test + fun indexOf_ULongArray() { + expect(-1) { ulongArrayOf(1uL, 2uL, 3uL).indexOf(0uL) } + expect(0) { ulongArrayOf(1uL, 2uL, 3uL).indexOf(1uL) } + expect(1) { ulongArrayOf(1uL, 2uL, 3uL).indexOf(2uL) } + expect(2) { ulongArrayOf(1uL, 2uL, 3uL).indexOf(3uL) } + } + + @Test + fun indexOf_UByteArray() { + expect(-1) { ubyteArrayOf(1u, 2u, 3u).indexOf(0u) } + expect(0) { ubyteArrayOf(1u, 2u, 3u).indexOf(1u) } + expect(1) { ubyteArrayOf(1u, 2u, 3u).indexOf(2u) } + expect(2) { ubyteArrayOf(1u, 2u, 3u).indexOf(3u) } + } + + @Test + fun indexOf_UShortArray() { + expect(-1) { ushortArrayOf(1u, 2u, 3u).indexOf(0u) } + expect(0) { ushortArrayOf(1u, 2u, 3u).indexOf(1u) } + expect(1) { ushortArrayOf(1u, 2u, 3u).indexOf(2u) } + expect(2) { ushortArrayOf(1u, 2u, 3u).indexOf(3u) } + } + + @Test + fun indexOfFirst_UIntArray() { + expect(-1) { uintArrayOf(1u, 2u, 3u).indexOfFirst { it == 0u } } + expect(0) { uintArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 1u } } + expect(1) { uintArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 0u } } + expect(2) { uintArrayOf(1u, 2u, 3u).indexOfFirst { it == 3u } } + } + + @Test + fun indexOfFirst_ULongArray() { + expect(-1) { ulongArrayOf(1uL, 2uL, 3uL).indexOfFirst { it == 0uL } } + expect(0) { ulongArrayOf(1uL, 2uL, 3uL).indexOfFirst { it % 2uL == 1uL } } + expect(1) { ulongArrayOf(1uL, 2uL, 3uL).indexOfFirst { it % 2uL == 0uL } } + expect(2) { ulongArrayOf(1uL, 2uL, 3uL).indexOfFirst { it == 3uL } } + } + + @Test + fun indexOfFirst_UByteArray() { + expect(-1) { ubyteArrayOf(1u, 2u, 3u).indexOfFirst { it == 0.toUByte() } } + expect(0) { ubyteArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 1u } } + expect(1) { ubyteArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 0u } } + expect(2) { ubyteArrayOf(1u, 2u, 3u).indexOfFirst { it == 3.toUByte() } } + } + + @Test + fun indexOfFirst_UShortArray() { + expect(-1) { ushortArrayOf(1u, 2u, 3u).indexOfFirst { it == 0.toUShort() } } + expect(0) { ushortArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 1u } } + expect(1) { ushortArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 0u } } + expect(2) { ushortArrayOf(1u, 2u, 3u).indexOfFirst { it == 3.toUShort() } } + } + + @Test + fun copyInto_UIntArray() { + val dest = uintArrayOf(1u, 2u, 3u) + val newValues = uintArrayOf(4u, 5u, 6u) + newValues.copyInto(dest, 0, 1, 3) + val result1 = uintArrayOf(5u, 6u, 3u) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = uintArrayOf(6u, 3u, 3u) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = uintArrayOf(6u, 6u, 3u) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_ULongArray() { + val dest = ulongArrayOf(1uL, 2uL, 3uL) + val newValues = ulongArrayOf(4uL, 5uL, 6uL) + newValues.copyInto(dest, 0, 1, 3) + val result1 = ulongArrayOf(5uL, 6uL, 3uL) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = ulongArrayOf(6uL, 3uL, 3uL) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = ulongArrayOf(6uL, 6uL, 3uL) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_UByteArray() { + val dest = ubyteArrayOf(1u, 2u, 3u) + val newValues = ubyteArrayOf(4u, 5u, 6u) + newValues.copyInto(dest, 0, 1, 3) + val result1 = ubyteArrayOf(5u, 6u, 3u) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = ubyteArrayOf(6u, 3u, 3u) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = ubyteArrayOf(6u, 6u, 3u) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun copyInto_UShortArray() { + val dest = ushortArrayOf(1u, 2u, 3u) + val newValues = ushortArrayOf(4u, 5u, 6u) + newValues.copyInto(dest, 0, 1, 3) + val result1 = ushortArrayOf(5u, 6u, 3u) + assertTrue(result1 contentEquals dest, "Copying from newValues: ${result1.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 0, 1, 3) + val result2 = ushortArrayOf(6u, 3u, 3u) + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${result2.contentToString()}, ${dest.contentToString()}") + dest.copyInto(dest, 1, 0, 2) + val result3 = ushortArrayOf(6u, 6u, 3u) + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${result2.contentToString()}, ${dest.contentToString()}") + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: $start, end: $end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: $ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: $destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + } + + @Test + fun reverse_UIntArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toUInt() }.toUIntArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_ULongArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toULong() }.toULongArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_UByteArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toUByte() }.toUByteArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverse_UShortArray() { + val arrays = (0..4).map { n -> (1..n).map { it.toUShort() }.toUShortArray() } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + } + + @Test + fun reverseRange_UIntArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toUInt() }.toUIntArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_ULongArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toULong() }.toULongArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_UByteArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toUByte() }.toUByteArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reverseRange_UShortArray() { + val arrays = (0..7).map { n -> n to (0 until n).map { it.toUShort() }.toUShortArray() } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + } + + @Test + fun reversed_UIntArray() { + assertEquals(listOf<UInt>(3u, 2u, 1u), uintArrayOf(1u, 2u, 3u).reversed()) + } + + @Test + fun reversed_ULongArray() { + assertEquals(listOf<ULong>(3uL, 2uL, 1uL), ulongArrayOf(1uL, 2uL, 3uL).reversed()) + } + + @Test + fun reversed_UByteArray() { + assertEquals(listOf<UByte>(3u, 2u, 1u), ubyteArrayOf(1u, 2u, 3u).reversed()) + } + + @Test + fun reversed_UShortArray() { + assertEquals(listOf<UShort>(3u, 2u, 1u), ushortArrayOf(1u, 2u, 3u).reversed()) + } + + @Test + fun reversedArray_UIntArray() { + assertArrayContentEquals(uintArrayOf(3u, 2u, 1u), uintArrayOf(1u, 2u, 3u).reversedArray()) + } + + @Test + fun reversedArray_ULongArray() { + assertArrayContentEquals(ulongArrayOf(3uL, 2uL, 1uL), ulongArrayOf(1uL, 2uL, 3uL).reversedArray()) + } + + @Test + fun reversedArray_UByteArray() { + assertArrayContentEquals(ubyteArrayOf(3u, 2u, 1u), ubyteArrayOf(1u, 2u, 3u).reversedArray()) + } + + @Test + fun reversedArray_UShortArray() { + assertArrayContentEquals(ushortArrayOf(3u, 2u, 1u), ushortArrayOf(1u, 2u, 3u).reversedArray()) + } + + @Test + fun shuffle_UIntArray() { + fun test(data: UIntArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(UIntArray(100) { it.toUInt() }) + } + + @Test + fun shuffle_ULongArray() { + fun test(data: ULongArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(ULongArray(100) { it.toULong() }) + } + + @Test + fun shuffle_UByteArray() { + fun test(data: UByteArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(UByteArray(100) { it.toUByte() }) + } + + @Test + fun shuffle_UShortArray() { + fun test(data: UShortArray) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test(UShortArray(100) { it.toUShort() }) + } + + @Test + fun shuffleRandom_UIntArray() { + fun test(data: UIntArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(UIntArray(16) { it.toUInt() }) + } + + @Test + fun shuffleRandom_ULongArray() { + fun test(data: ULongArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(ULongArray(16) { it.toULong() }) + } + + @Test + fun shuffleRandom_UByteArray() { + fun test(data: UByteArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(UByteArray(16) { it.toUByte() }) + } + + @Test + fun shuffleRandom_UShortArray() { + fun test(data: UShortArray) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test(UShortArray(16) { it.toUShort() }) + } + + @Test + fun sort_UIntArray() { + val data = uintArrayOf(5u, 2u, 1u, 9u, 80u, UInt.MIN_VALUE, UInt.MAX_VALUE) + data.sort() + assertArrayContentEquals(uintArrayOf(UInt.MIN_VALUE, 1u, 2u, 5u, 9u, 80u, UInt.MAX_VALUE), data) + } + + @Test + fun sort_ULongArray() { + val data = ulongArrayOf(5uL, 2uL, 1uL, 9uL, 80uL, ULong.MIN_VALUE, ULong.MAX_VALUE) + data.sort() + assertArrayContentEquals(ulongArrayOf(ULong.MIN_VALUE, 1uL, 2uL, 5uL, 9uL, 80uL, ULong.MAX_VALUE), data) + } + + @Test + fun sort_UByteArray() { + val data = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, UByte.MIN_VALUE, UByte.MAX_VALUE) + data.sort() + assertArrayContentEquals(ubyteArrayOf(UByte.MIN_VALUE, 1u, 2u, 5u, 9u, 80u, UByte.MAX_VALUE), data) + } + + @Test + fun sort_UShortArray() { + val data = ushortArrayOf(5u, 2u, 1u, 9u, 80u, UShort.MIN_VALUE, UShort.MAX_VALUE) + data.sort() + assertArrayContentEquals(ushortArrayOf(UShort.MIN_VALUE, 1u, 2u, 5u, 9u, 80u, UShort.MAX_VALUE), data) + } + + @Test + fun sortDescending_UIntArray() { + val data = uintArrayOf(5u, 2u, 1u, 9u, 80u, UInt.MIN_VALUE, UInt.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(uintArrayOf(UInt.MIN_VALUE, 1u, 2u, 5u, 9u, 80u, UInt.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sortDescending_ULongArray() { + val data = ulongArrayOf(5uL, 2uL, 1uL, 9uL, 80uL, ULong.MIN_VALUE, ULong.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(ulongArrayOf(ULong.MIN_VALUE, 1uL, 2uL, 5uL, 9uL, 80uL, ULong.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sortDescending_UByteArray() { + val data = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, UByte.MIN_VALUE, UByte.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(ubyteArrayOf(UByte.MIN_VALUE, 1u, 2u, 5u, 9u, 80u, UByte.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sortDescending_UShortArray() { + val data = ushortArrayOf(5u, 2u, 1u, 9u, 80u, UShort.MIN_VALUE, UShort.MAX_VALUE) + data.sortDescending() + assertArrayContentEquals(ushortArrayOf(UShort.MIN_VALUE, 1u, 2u, 5u, 9u, 80u, UShort.MAX_VALUE).reversedArray(), data) + } + + @Test + fun sorted_UIntArray() { + uintArrayOf(3u, 7u, 1u).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + uintArrayOf(1u, UInt.MAX_VALUE, UInt.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_ULongArray() { + ulongArrayOf(3uL, 7uL, 1uL).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + ulongArrayOf(1uL, ULong.MAX_VALUE, ULong.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_UByteArray() { + ubyteArrayOf(3u, 7u, 1u).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + ubyteArrayOf(1u, UByte.MAX_VALUE, UByte.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sorted_UShortArray() { + ushortArrayOf(3u, 7u, 1u).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + ushortArrayOf(1u, UShort.MAX_VALUE, UShort.MIN_VALUE).sorted().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_UIntArray() { + uintArrayOf(3u, 7u, 1u).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + uintArrayOf(1u, UInt.MAX_VALUE, UInt.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_ULongArray() { + ulongArrayOf(3uL, 7uL, 1uL).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + ulongArrayOf(1uL, ULong.MAX_VALUE, ULong.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_UByteArray() { + ubyteArrayOf(3u, 7u, 1u).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + ubyteArrayOf(1u, UByte.MAX_VALUE, UByte.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArray_UShortArray() { + ushortArrayOf(3u, 7u, 1u).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + ushortArrayOf(1u, UShort.MAX_VALUE, UShort.MIN_VALUE).sortedArray().iterator().assertSorted { a, b -> a.compareTo(b) <= 0 } + } + + @Test + fun sortedArrayDescending_UIntArray() { + uintArrayOf(3u, 7u, 1u).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + uintArrayOf(1u, UInt.MAX_VALUE, UInt.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_ULongArray() { + ulongArrayOf(3uL, 7uL, 1uL).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + ulongArrayOf(1uL, ULong.MAX_VALUE, ULong.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_UByteArray() { + ubyteArrayOf(3u, 7u, 1u).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + ubyteArrayOf(1u, UByte.MAX_VALUE, UByte.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedArrayDescending_UShortArray() { + ushortArrayOf(3u, 7u, 1u).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + ushortArrayOf(1u, UShort.MAX_VALUE, UShort.MIN_VALUE).sortedArrayDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_UIntArray() { + uintArrayOf(3u, 7u, 1u).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + uintArrayOf(1u, UInt.MAX_VALUE, UInt.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_ULongArray() { + ulongArrayOf(3uL, 7uL, 1uL).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + ulongArrayOf(1uL, ULong.MAX_VALUE, ULong.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_UByteArray() { + ubyteArrayOf(3u, 7u, 1u).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + ubyteArrayOf(1u, UByte.MAX_VALUE, UByte.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + + @Test + fun sortedDescending_UShortArray() { + ushortArrayOf(3u, 7u, 1u).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + ushortArrayOf(1u, UShort.MAX_VALUE, UShort.MIN_VALUE).sortedDescending().iterator().assertSorted { a, b -> a.compareTo(b) >= 0 } + } + +}
diff --git a/libraries/stdlib/test/generated/_UComparisonsTest.kt b/libraries/stdlib/test/generated/_UComparisonsTest.kt new file mode 100644 index 0000000..f749741 --- /dev/null +++ b/libraries/stdlib/test/generated/_UComparisonsTest.kt
@@ -0,0 +1,249 @@ +/* + * 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.unsigned + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLibTests.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.random.* +import kotlin.test.* + +class _UComparisonsTest { + @Test + fun maxOf_2_UInt() { + expect(2u) { maxOf(2u, 1u) } + expect(126u) { maxOf(58u, 126u) } + expect(23u) { maxOf(Random.nextUInt(UInt.MIN_VALUE, 23u), 23u) } + expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE) } + expect(UInt.MIN_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MIN_VALUE) } + } + + @Test + fun maxOf_2_ULong() { + expect(2uL) { maxOf(2uL, 1uL) } + expect(126uL) { maxOf(58uL, 126uL) } + expect(23uL) { maxOf(Random.nextULong(ULong.MIN_VALUE, 23uL), 23uL) } + expect(ULong.MAX_VALUE) { maxOf(ULong.MIN_VALUE, ULong.MAX_VALUE) } + expect(ULong.MIN_VALUE) { maxOf(ULong.MIN_VALUE, ULong.MIN_VALUE) } + } + + @Test + fun maxOf_2_UByte() { + expect(2.toUByte()) { maxOf(2.toUByte(), 1.toUByte()) } + expect(126.toUByte()) { maxOf(58.toUByte(), 126.toUByte()) } + expect(23.toUByte()) { maxOf(Random.nextInt(UByte.MIN_VALUE.toInt(), 23).toUByte(), 23.toUByte()) } + expect(UByte.MAX_VALUE) { maxOf(UByte.MIN_VALUE, UByte.MAX_VALUE) } + expect(UByte.MIN_VALUE) { maxOf(UByte.MIN_VALUE, UByte.MIN_VALUE) } + } + + @Test + fun maxOf_2_UShort() { + expect(2.toUShort()) { maxOf(2.toUShort(), 1.toUShort()) } + expect(126.toUShort()) { maxOf(58.toUShort(), 126.toUShort()) } + expect(23.toUShort()) { maxOf(Random.nextInt(UShort.MIN_VALUE.toInt(), 23).toUShort(), 23.toUShort()) } + expect(UShort.MAX_VALUE) { maxOf(UShort.MIN_VALUE, UShort.MAX_VALUE) } + expect(UShort.MIN_VALUE) { maxOf(UShort.MIN_VALUE, UShort.MIN_VALUE) } + } + + @Test + fun maxOf_3_UInt() { + expect(3u) { maxOf(2u, 1u, 3u) } + expect(126u) { maxOf(58u, 126u, 55u) } + expect(23u) { maxOf(Random.nextUInt(UInt.MIN_VALUE, 23u), 23u, Random.nextUInt(UInt.MIN_VALUE, 23u)) } + expect(UInt.MIN_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MIN_VALUE, UInt.MIN_VALUE) } + expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u) } + + } + + @Test + fun maxOf_3_ULong() { + expect(3uL) { maxOf(2uL, 1uL, 3uL) } + expect(126uL) { maxOf(58uL, 126uL, 55uL) } + expect(23uL) { maxOf(Random.nextULong(ULong.MIN_VALUE, 23uL), 23uL, Random.nextULong(ULong.MIN_VALUE, 23uL)) } + expect(ULong.MIN_VALUE) { maxOf(ULong.MIN_VALUE, ULong.MIN_VALUE, ULong.MIN_VALUE) } + expect(ULong.MAX_VALUE) { maxOf(ULong.MIN_VALUE, ULong.MAX_VALUE, 0uL) } + + } + + @Test + fun maxOf_3_UByte() { + expect(3.toUByte()) { maxOf(2.toUByte(), 1.toUByte(), 3.toUByte()) } + expect(126.toUByte()) { maxOf(58.toUByte(), 126.toUByte(), 55.toUByte()) } + expect(23.toUByte()) { maxOf(Random.nextInt(UByte.MIN_VALUE.toInt(), 23).toUByte(), 23.toUByte(), Random.nextInt(UByte.MIN_VALUE.toInt(), 23).toUByte()) } + expect(UByte.MIN_VALUE) { maxOf(UByte.MIN_VALUE, UByte.MIN_VALUE, UByte.MIN_VALUE) } + expect(UByte.MAX_VALUE) { maxOf(UByte.MIN_VALUE, UByte.MAX_VALUE, 0.toUByte()) } + + } + + @Test + fun maxOf_3_UShort() { + expect(3.toUShort()) { maxOf(2.toUShort(), 1.toUShort(), 3.toUShort()) } + expect(126.toUShort()) { maxOf(58.toUShort(), 126.toUShort(), 55.toUShort()) } + expect(23.toUShort()) { maxOf(Random.nextInt(UShort.MIN_VALUE.toInt(), 23).toUShort(), 23.toUShort(), Random.nextInt(UShort.MIN_VALUE.toInt(), 23).toUShort()) } + expect(UShort.MIN_VALUE) { maxOf(UShort.MIN_VALUE, UShort.MIN_VALUE, UShort.MIN_VALUE) } + expect(UShort.MAX_VALUE) { maxOf(UShort.MIN_VALUE, UShort.MAX_VALUE, 0.toUShort()) } + + } + + @Test + fun maxOf_vararg_UInt() { + expect(10u) { maxOf(2u, 1u, 3u, 10u) } + expect(126u) { maxOf(58u, 126u, 55u, 87u) } + expect(23u) { maxOf(Random.nextUInt(UInt.MIN_VALUE, 23u), 23u, Random.nextUInt(UInt.MIN_VALUE, 23u), 21u) } + expect(UInt.MIN_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MIN_VALUE, UInt.MIN_VALUE, UInt.MIN_VALUE) } + expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u, 1u) } + + } + + @Test + fun maxOf_vararg_ULong() { + expect(10uL) { maxOf(2uL, 1uL, 3uL, 10uL) } + expect(126uL) { maxOf(58uL, 126uL, 55uL, 87uL) } + expect(23uL) { maxOf(Random.nextULong(ULong.MIN_VALUE, 23uL), 23uL, Random.nextULong(ULong.MIN_VALUE, 23uL), 21uL) } + expect(ULong.MIN_VALUE) { maxOf(ULong.MIN_VALUE, ULong.MIN_VALUE, ULong.MIN_VALUE, ULong.MIN_VALUE) } + expect(ULong.MAX_VALUE) { maxOf(ULong.MIN_VALUE, ULong.MAX_VALUE, 0uL, 1uL) } + + } + + @Test + fun maxOf_vararg_UByte() { + expect(10.toUByte()) { maxOf(2.toUByte(), 1.toUByte(), 3.toUByte(), 10.toUByte()) } + expect(126.toUByte()) { maxOf(58.toUByte(), 126.toUByte(), 55.toUByte(), 87.toUByte()) } + expect(23.toUByte()) { maxOf(Random.nextInt(UByte.MIN_VALUE.toInt(), 23).toUByte(), 23.toUByte(), Random.nextInt(UByte.MIN_VALUE.toInt(), 23).toUByte(), 21.toUByte()) } + expect(UByte.MIN_VALUE) { maxOf(UByte.MIN_VALUE, UByte.MIN_VALUE, UByte.MIN_VALUE, UByte.MIN_VALUE) } + expect(UByte.MAX_VALUE) { maxOf(UByte.MIN_VALUE, UByte.MAX_VALUE, 0.toUByte(), 1.toUByte()) } + + } + + @Test + fun maxOf_vararg_UShort() { + expect(10.toUShort()) { maxOf(2.toUShort(), 1.toUShort(), 3.toUShort(), 10.toUShort()) } + expect(126.toUShort()) { maxOf(58.toUShort(), 126.toUShort(), 55.toUShort(), 87.toUShort()) } + expect(23.toUShort()) { maxOf(Random.nextInt(UShort.MIN_VALUE.toInt(), 23).toUShort(), 23.toUShort(), Random.nextInt(UShort.MIN_VALUE.toInt(), 23).toUShort(), 21.toUShort()) } + expect(UShort.MIN_VALUE) { maxOf(UShort.MIN_VALUE, UShort.MIN_VALUE, UShort.MIN_VALUE, UShort.MIN_VALUE) } + expect(UShort.MAX_VALUE) { maxOf(UShort.MIN_VALUE, UShort.MAX_VALUE, 0.toUShort(), 1.toUShort()) } + + } + + @Test + fun minOf_2_UInt() { + expect(1u) { minOf(2u, 1u) } + expect(58u) { minOf(58u, 126u) } + expect(23u) { minOf(Random.nextUInt(23u..UInt.MAX_VALUE), 23u) } + expect(UInt.MIN_VALUE) { minOf(UInt.MIN_VALUE, UInt.MAX_VALUE) } + expect(UInt.MAX_VALUE) { minOf(UInt.MAX_VALUE, UInt.MAX_VALUE) } + } + + @Test + fun minOf_2_ULong() { + expect(1uL) { minOf(2uL, 1uL) } + expect(58uL) { minOf(58uL, 126uL) } + expect(23uL) { minOf(Random.nextULong(23uL..ULong.MAX_VALUE), 23uL) } + expect(ULong.MIN_VALUE) { minOf(ULong.MIN_VALUE, ULong.MAX_VALUE) } + expect(ULong.MAX_VALUE) { minOf(ULong.MAX_VALUE, ULong.MAX_VALUE) } + } + + @Test + fun minOf_2_UByte() { + expect(1.toUByte()) { minOf(2.toUByte(), 1.toUByte()) } + expect(58.toUByte()) { minOf(58.toUByte(), 126.toUByte()) } + expect(23.toUByte()) { minOf(Random.nextInt(23..UByte.MAX_VALUE.toInt()).toUByte(), 23.toUByte()) } + expect(UByte.MIN_VALUE) { minOf(UByte.MIN_VALUE, UByte.MAX_VALUE) } + expect(UByte.MAX_VALUE) { minOf(UByte.MAX_VALUE, UByte.MAX_VALUE) } + } + + @Test + fun minOf_2_UShort() { + expect(1.toUShort()) { minOf(2.toUShort(), 1.toUShort()) } + expect(58.toUShort()) { minOf(58.toUShort(), 126.toUShort()) } + expect(23.toUShort()) { minOf(Random.nextInt(23..UShort.MAX_VALUE.toInt()).toUShort(), 23.toUShort()) } + expect(UShort.MIN_VALUE) { minOf(UShort.MIN_VALUE, UShort.MAX_VALUE) } + expect(UShort.MAX_VALUE) { minOf(UShort.MAX_VALUE, UShort.MAX_VALUE) } + } + + @Test + fun minOf_3_UInt() { + expect(1u) { minOf(2u, 1u, 3u) } + expect(55u) { minOf(58u, 126u, 55u) } + expect(23u) { minOf(Random.nextUInt(23u..UInt.MAX_VALUE), 23u, Random.nextUInt(23u..UInt.MAX_VALUE)) } + expect(UInt.MAX_VALUE) { minOf(UInt.MAX_VALUE, UInt.MAX_VALUE, UInt.MAX_VALUE) } + expect(UInt.MIN_VALUE) { minOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u) } + + } + + @Test + fun minOf_3_ULong() { + expect(1uL) { minOf(2uL, 1uL, 3uL) } + expect(55uL) { minOf(58uL, 126uL, 55uL) } + expect(23uL) { minOf(Random.nextULong(23uL..ULong.MAX_VALUE), 23uL, Random.nextULong(23uL..ULong.MAX_VALUE)) } + expect(ULong.MAX_VALUE) { minOf(ULong.MAX_VALUE, ULong.MAX_VALUE, ULong.MAX_VALUE) } + expect(ULong.MIN_VALUE) { minOf(ULong.MIN_VALUE, ULong.MAX_VALUE, 0uL) } + + } + + @Test + fun minOf_3_UByte() { + expect(1.toUByte()) { minOf(2.toUByte(), 1.toUByte(), 3.toUByte()) } + expect(55.toUByte()) { minOf(58.toUByte(), 126.toUByte(), 55.toUByte()) } + expect(23.toUByte()) { minOf(Random.nextInt(23..UByte.MAX_VALUE.toInt()).toUByte(), 23.toUByte(), Random.nextInt(23..UByte.MAX_VALUE.toInt()).toUByte()) } + expect(UByte.MAX_VALUE) { minOf(UByte.MAX_VALUE, UByte.MAX_VALUE, UByte.MAX_VALUE) } + expect(UByte.MIN_VALUE) { minOf(UByte.MIN_VALUE, UByte.MAX_VALUE, 0u) } + + } + + @Test + fun minOf_3_UShort() { + expect(1.toUShort()) { minOf(2.toUShort(), 1.toUShort(), 3.toUShort()) } + expect(55.toUShort()) { minOf(58.toUShort(), 126.toUShort(), 55.toUShort()) } + expect(23.toUShort()) { minOf(Random.nextInt(23..UShort.MAX_VALUE.toInt()).toUShort(), 23.toUShort(), Random.nextInt(23..UShort.MAX_VALUE.toInt()).toUShort()) } + expect(UShort.MAX_VALUE) { minOf(UShort.MAX_VALUE, UShort.MAX_VALUE, UShort.MAX_VALUE) } + expect(UShort.MIN_VALUE) { minOf(UShort.MIN_VALUE, UShort.MAX_VALUE, 0u) } + + } + + @Test + fun minOf_vararg_UInt() { + expect(1u) { minOf(2u, 1u, 3u, 10u) } + expect(55u) { minOf(58u, 126u, 55u, 87u) } + expect(21u) { minOf(Random.nextUInt(23u..UInt.MAX_VALUE), 23u, Random.nextUInt(23u..UInt.MAX_VALUE), 21u) } + expect(UInt.MAX_VALUE) { minOf(UInt.MAX_VALUE, UInt.MAX_VALUE, UInt.MAX_VALUE, UInt.MAX_VALUE) } + assertEquals(UInt.MIN_VALUE, minOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u, 1u)) + + } + + @Test + fun minOf_vararg_ULong() { + expect(1uL) { minOf(2uL, 1uL, 3uL, 10uL) } + expect(55uL) { minOf(58uL, 126uL, 55uL, 87uL) } + expect(21uL) { minOf(Random.nextULong(23uL..ULong.MAX_VALUE), 23uL, Random.nextULong(23uL..ULong.MAX_VALUE), 21uL) } + expect(ULong.MAX_VALUE) { minOf(ULong.MAX_VALUE, ULong.MAX_VALUE, ULong.MAX_VALUE, ULong.MAX_VALUE) } + assertEquals(ULong.MIN_VALUE, minOf(ULong.MIN_VALUE, ULong.MAX_VALUE, 0uL, 1uL)) + + } + + @Test + fun minOf_vararg_UByte() { + expect(1.toUByte()) { minOf(2.toUByte(), 1.toUByte(), 3.toUByte(), 10.toUByte()) } + expect(55.toUByte()) { minOf(58.toUByte(), 126.toUByte(), 55.toUByte(), 87.toUByte()) } + expect(21.toUByte()) { minOf(Random.nextInt(23..UByte.MAX_VALUE.toInt()).toUByte(), 23.toUByte(), Random.nextInt(23..UByte.MAX_VALUE.toInt()).toUByte(), 21.toUByte()) } + expect(UByte.MAX_VALUE) { minOf(UByte.MAX_VALUE, UByte.MAX_VALUE, UByte.MAX_VALUE, UByte.MAX_VALUE) } + assertEquals(UByte.MIN_VALUE, minOf(UByte.MIN_VALUE, UByte.MAX_VALUE, 0.toUByte(), 1.toUByte())) + + } + + @Test + fun minOf_vararg_UShort() { + expect(1.toUShort()) { minOf(2.toUShort(), 1.toUShort(), 3.toUShort(), 10.toUShort()) } + expect(55.toUShort()) { minOf(58.toUShort(), 126.toUShort(), 55.toUShort(), 87.toUShort()) } + expect(21.toUShort()) { minOf(Random.nextInt(23..UShort.MAX_VALUE.toInt()).toUShort(), 23.toUShort(), Random.nextInt(23..UShort.MAX_VALUE.toInt()).toUShort(), 21.toUShort()) } + expect(UShort.MAX_VALUE) { minOf(UShort.MAX_VALUE, UShort.MAX_VALUE, UShort.MAX_VALUE, UShort.MAX_VALUE) } + assertEquals(UShort.MIN_VALUE, minOf(UShort.MIN_VALUE, UShort.MAX_VALUE, 0.toUShort(), 1.toUShort())) + + } + +}
diff --git a/libraries/stdlib/test/unsigned/UNumbersTest.kt b/libraries/stdlib/test/generated/_UnsignedTest.kt similarity index 92% rename from libraries/stdlib/test/unsigned/UNumbersTest.kt rename to libraries/stdlib/test/generated/_UnsignedTest.kt index 82baa83..d37900e 100644 --- a/libraries/stdlib/test/unsigned/UNumbersTest.kt +++ b/libraries/stdlib/test/generated/_UnsignedTest.kt
@@ -1,18 +1,58 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * 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.unsigned +// +// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLibTests.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + import kotlin.random.* import kotlin.test.* - -class NumbersTest { +class _UnsignedTest { + @Test + fun bits_UInt() { + fun test(value: UInt, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { + assertEquals(oneBits, value.countOneBits()) + assertEquals(leadingZeroes, value.countLeadingZeroBits()) + assertEquals(trailingZeroes, value.countTrailingZeroBits()) + val highestBit = if (leadingZeroes < UInt.SIZE_BITS) 1u.shl(UInt.SIZE_BITS - leadingZeroes - 1).toUInt() else 0u + val lowestBit = if (trailingZeroes < UInt.SIZE_BITS) 1u.shl(trailingZeroes).toUInt() else 0u + assertEquals(highestBit, value.takeHighestOneBit()) + assertEquals(lowestBit, value.takeLowestOneBit()) + } + test(0u, 0, 32, 32) + test(1u, 1, 31, 0) + test(2u, 1, 30, 1) + test(0xF002u, 5, 16, 1) + test(0xF00F0000u, 8, 0, 16) + } @Test - fun ubyteBits() { + fun bits_ULong() { + fun test(value: ULong, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { + assertEquals(oneBits, value.countOneBits()) + assertEquals(leadingZeroes, value.countLeadingZeroBits()) + assertEquals(trailingZeroes, value.countTrailingZeroBits()) + val highestBit = if (leadingZeroes < ULong.SIZE_BITS) 1uL.shl(ULong.SIZE_BITS - leadingZeroes - 1).toULong() else 0uL + val lowestBit = if (trailingZeroes < ULong.SIZE_BITS) 1uL.shl(trailingZeroes).toULong() else 0uL + assertEquals(highestBit, value.takeHighestOneBit()) + assertEquals(lowestBit, value.takeLowestOneBit()) + } + test(0uL, 0, 64, 64) + test(1uL, 1, 63, 0) + test(2uL, 1, 62, 1) + test(0xF002uL, 5, 48, 1) + test(0xF00F0000uL, 8, 32, 16) + test(0x1111_3333_EEEE_0000uL, 4 + 8 + 12, 3, 17) + } + + @Test + fun bits_UByte() { fun test(value: UByte, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { assertEquals(oneBits, value.countOneBits()) assertEquals(leadingZeroes, value.countLeadingZeroBits()) @@ -22,7 +62,6 @@ assertEquals(highestBit, value.takeHighestOneBit()) assertEquals(lowestBit, value.takeLowestOneBit()) } - test(0u, 0, 8, 8) test(1u, 1, 7, 0) test(2u, 1, 6, 1) @@ -32,7 +71,7 @@ } @Test - fun ushortBits() { + fun bits_UShort() { fun test(value: UShort, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { assertEquals(oneBits, value.countOneBits()) assertEquals(leadingZeroes, value.countLeadingZeroBits()) @@ -42,7 +81,6 @@ assertEquals(highestBit, value.takeHighestOneBit()) assertEquals(lowestBit, value.takeLowestOneBit()) } - test(0u, 0, 16, 16) test(1u, 1, 15, 0) test(2u, 1, 14, 1) @@ -52,52 +90,11 @@ } @Test - fun uintBits() { - fun test(value: UInt, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { - assertEquals(oneBits, value.countOneBits()) - assertEquals(leadingZeroes, value.countLeadingZeroBits()) - assertEquals(trailingZeroes, value.countTrailingZeroBits()) - val highestBit = if (leadingZeroes < UInt.SIZE_BITS) 1u.shl(UInt.SIZE_BITS - leadingZeroes - 1) else 0u - val lowestBit = if (trailingZeroes < UInt.SIZE_BITS) 1u.shl(trailingZeroes) else 0u - assertEquals(highestBit, value.takeHighestOneBit()) - assertEquals(lowestBit, value.takeLowestOneBit()) - } - - test(0u, 0, 32, 32) - test(1u, 1, 31, 0) - test(2u, 1, 30, 1) - test(0xF002u, 5, 16, 1) - test(0xF00F0000u, 8, 0, 16) - } - - @Test - fun ulongBits() { - fun test(value: ULong, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { - assertEquals(oneBits, value.countOneBits()) - assertEquals(leadingZeroes, value.countLeadingZeroBits()) - assertEquals(trailingZeroes, value.countTrailingZeroBits()) - val highestBit = if (leadingZeroes < ULong.SIZE_BITS) 1uL.shl(ULong.SIZE_BITS - leadingZeroes - 1).toULong() else 0u - val lowestBit = if (trailingZeroes < ULong.SIZE_BITS) 1uL.shl(trailingZeroes).toULong() else 0u - assertEquals(highestBit, value.takeHighestOneBit()) - assertEquals(lowestBit, value.takeLowestOneBit()) - } - - test(0uL, 0, 64, 64) - test(1uL, 1, 63, 0) - test(2uL, 1, 62, 1) - test(0xF002uL, 5, 48, 1) - test(0xF00F0000uL, 8, 32, 16) - test(0x1111_3333_EEEE_0000uL, 4 + 8 + 12, 3, 17) - } - - - @Test - fun uintRotate() { + fun rotate_UInt() { fun test(value: UInt, n: Int, expected: UInt) { assertEquals(expected, value.rotateLeft(n)) assertEquals(expected, value.rotateRight(-n)) } - fun testCyclic(value: UInt) { for (n in -2 * UInt.SIZE_BITS..2 * UInt.SIZE_BITS) { val rl = value.rotateLeft(n) @@ -109,7 +106,6 @@ assertEquals(value, value.rotateRight(n).rotateRight(-n)) } } - test(0x7_3422345u, 4, 0x3422345_7u) test(0x7342234_5u, -4, 0x5_7342234u) test(0x73422345u, 1, 0xE684468Au) @@ -119,40 +115,11 @@ } @Test - fun ubyteRotate() { - fun test(value: UByte, n: Int, expected: UByte) { - assertEquals(expected, value.rotateLeft(n)) - assertEquals(expected, value.rotateRight(-n)) - } - - fun testCyclic(value: UByte) { - for (n in -2 * UByte.SIZE_BITS..2 * UByte.SIZE_BITS) { - val rl = value.rotateLeft(n) - val rr = value.rotateRight(-n) - assertEquals(rl, rr) - assertEquals(rl, value.rotateLeft(n % UByte.SIZE_BITS)) - assertEquals(rr, value.rotateRight((-n) % UByte.SIZE_BITS)) - assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) - assertEquals(value, value.rotateRight(n).rotateRight(-n)) - } - } - - test(0x73u, 4, 0x37u) - test(0x73u, -3, 0x6Eu) - test(0x73u, 1, 0xE6u) - test(0xE6u, 1, 0xCDu) - repeat(100) { - testCyclic(Random.nextInt().toUByte()) - } - } - - @Test - fun ulongRotate() { + fun rotate_ULong() { fun test(value: ULong, n: Int, expected: ULong) { assertEquals(expected, value.rotateLeft(n)) assertEquals(expected, value.rotateRight(-n)) } - fun testCyclic(value: ULong) { for (n in -2 * ULong.SIZE_BITS..2 * ULong.SIZE_BITS) { val rl = value.rotateLeft(n) @@ -164,7 +131,6 @@ assertEquals(value, value.rotateRight(n).rotateRight(-n)) } } - test(0x7372ABAC_DEEF0123uL, 4, 0x372ABAC_DEEF01237uL) test(0x88888888_44444444uL, -3, 0x91111111_08888888uL) test(0x88888888_44444444uL, 1, 0x11111110_88888889uL) @@ -174,12 +140,37 @@ } @Test - fun ushortRotate() { + fun rotate_UByte() { + fun test(value: UByte, n: Int, expected: UByte) { + assertEquals(expected, value.rotateLeft(n)) + assertEquals(expected, value.rotateRight(-n)) + } + fun testCyclic(value: UByte) { + for (n in -2 * UByte.SIZE_BITS..2 * UByte.SIZE_BITS) { + val rl = value.rotateLeft(n) + val rr = value.rotateRight(-n) + assertEquals(rl, rr) + assertEquals(rl, value.rotateLeft(n % UByte.SIZE_BITS)) + assertEquals(rr, value.rotateRight((-n) % UByte.SIZE_BITS)) + assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) + assertEquals(value, value.rotateRight(n).rotateRight(-n)) + } + } + test(0x73u, 4, 0x37u) + test(0x73u, -3, 0x6Eu) + test(0x73u, 1, 0xE6u) + test(0xE6u, 1, 0xCDu) + repeat(100) { + testCyclic(Random.nextInt().toUByte()) + } + } + + @Test + fun rotate_UShort() { fun test(value: UShort, n: Int, expected: UShort) { assertEquals(expected, value.rotateLeft(n)) assertEquals(expected, value.rotateRight(-n)) } - fun testCyclic(value: UShort) { for (n in -2 * UShort.SIZE_BITS..2 * UShort.SIZE_BITS) { val rl = value.rotateLeft(n) @@ -191,7 +182,6 @@ assertEquals(value, value.rotateRight(n).rotateRight(-n)) } } - test(0x7361u, 4, 0x3617u) test(0x7361u, -3, 0b001_0111_0011_0110_0u) test(0x7361u, 1, 0b111_0011_0110_0001_0u) @@ -201,4 +191,4 @@ } } -} \ No newline at end of file +}
diff --git a/libraries/stdlib/test/numbers/NumbersTest.kt b/libraries/stdlib/test/numbers/NumbersTest.kt index 990899e..cdf6a96 100644 --- a/libraries/stdlib/test/numbers/NumbersTest.kt +++ b/libraries/stdlib/test/numbers/NumbersTest.kt
@@ -6,7 +6,6 @@ package test.numbers import test.isFloat32RangeEnforced -import kotlin.random.Random import kotlin.test.* object NumbersTestConstants { @@ -252,194 +251,4 @@ testSizes(ULong, ULong.SIZE_BYTES, ULong.SIZE_BITS, 8) } - @Test - fun byteBits() { - fun test(value: Byte, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { - assertEquals(oneBits, value.countOneBits()) - assertEquals(leadingZeroes, value.countLeadingZeroBits()) - assertEquals(trailingZeroes, value.countTrailingZeroBits()) - val highestBit = if (leadingZeroes < Byte.SIZE_BITS) 1.shl(Byte.SIZE_BITS - leadingZeroes - 1).toByte() else 0 - val lowestBit = if (trailingZeroes < Byte.SIZE_BITS) 1.shl(trailingZeroes).toByte() else 0 - assertEquals(highestBit, value.takeHighestOneBit()) - assertEquals(lowestBit, value.takeLowestOneBit()) - } - - test(0, 0, 8, 8) - test(1, 1, 7, 0) - test(2, 1, 6, 1) - test(0x44, 2, 1, 2) - test(0x80.toByte(), 1, 0, 7) - test(0xF0.toByte(), 4, 0, 4) - } - - @Test - fun shortBits() { - fun test(value: Short, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { - assertEquals(oneBits, value.countOneBits()) - assertEquals(leadingZeroes, value.countLeadingZeroBits()) - assertEquals(trailingZeroes, value.countTrailingZeroBits()) - val highestBit = if (leadingZeroes < Short.SIZE_BITS) 1.shl(Short.SIZE_BITS - leadingZeroes - 1).toShort() else 0 - val lowestBit = if (trailingZeroes < Short.SIZE_BITS) 1.shl(trailingZeroes).toShort() else 0 - assertEquals(highestBit, value.takeHighestOneBit()) - assertEquals(lowestBit, value.takeLowestOneBit()) - } - - test(0, 0, 16, 16) - test(1, 1, 15, 0) - test(2, 1, 14, 1) - test(0xF2, 5, 8, 1) - test(0x8000.toShort(), 1, 0, 15) - test(0xF200.toShort(), 5, 0, 9) - } - - @Test - fun intBits() { - fun test(value: Int, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { - assertEquals(oneBits, value.countOneBits()) - assertEquals(leadingZeroes, value.countLeadingZeroBits()) - assertEquals(trailingZeroes, value.countTrailingZeroBits()) - val highestBit = if (leadingZeroes < Int.SIZE_BITS) 1.shl(Int.SIZE_BITS - leadingZeroes - 1) else 0 - val lowestBit = if (trailingZeroes < Int.SIZE_BITS) 1.shl(trailingZeroes) else 0 - assertEquals(highestBit, value.takeHighestOneBit()) - assertEquals(lowestBit, value.takeLowestOneBit()) - } - - test(0, 0, 32, 32) - test(1, 1, 31, 0) - test(2, 1, 30, 1) - test(0xF002, 5, 16, 1) - test(0xF00F0000.toInt(), 8, 0, 16) - } - - @Test - fun longBits() { - fun test(value: Long, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { - assertEquals(oneBits, value.countOneBits()) - assertEquals(leadingZeroes, value.countLeadingZeroBits()) - assertEquals(trailingZeroes, value.countTrailingZeroBits()) - val highestBit = if (leadingZeroes < Long.SIZE_BITS) 1L.shl(Long.SIZE_BITS - leadingZeroes - 1).toLong() else 0 - val lowestBit = if (trailingZeroes < Long.SIZE_BITS) 1L.shl(trailingZeroes).toLong() else 0 - assertEquals(highestBit, value.takeHighestOneBit()) - assertEquals(lowestBit, value.takeLowestOneBit()) - } - - test(0, 0, 64, 64) - test(1, 1, 63, 0) - test(2, 1, 62, 1) - test(0xF002, 5, 48, 1) - test(0xF00F0000L, 8, 32, 16) - test(0x1111_3333_EEEE_0000L, 4 + 8 + 12, 3, 17) - } - - - @Test - fun intRotate() { - fun test(value: Int, n: Int, expected: Int) { - assertEquals(expected, value.rotateLeft(n)) - assertEquals(expected, value.rotateRight(-n)) - } - - fun testCyclic(value: Int) { - for (n in -2 * Int.SIZE_BITS..2 * Int.SIZE_BITS) { - val rl = value.rotateLeft(n) - val rr = value.rotateRight(-n) - assertEquals(rl, rr) - assertEquals(rl, value.rotateLeft(n % Int.SIZE_BITS)) - assertEquals(rr, value.rotateRight((-n) % Int.SIZE_BITS)) - assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) - assertEquals(value, value.rotateRight(n).rotateRight(-n)) - } - } - - test(0x7_3422345, 4, 0x3422345_7) - test(0x7342234_5, -4, 0x5_7342234) - test(0x73422345, 1, 0xE684468A.toInt()) - repeat(100) { - testCyclic(Random.nextInt()) - } - } - - @Test - fun byteRotate() { - fun test(value: Byte, n: Int, expected: Byte) { - assertEquals(expected, value.rotateLeft(n)) - assertEquals(expected, value.rotateRight(-n)) - } - - fun testCyclic(value: Byte) { - for (n in -2 * Byte.SIZE_BITS..2 * Byte.SIZE_BITS) { - val rl = value.rotateLeft(n) - val rr = value.rotateRight(-n) - assertEquals(rl, rr) - assertEquals(rl, value.rotateLeft(n % Byte.SIZE_BITS)) - assertEquals(rr, value.rotateRight((-n) % Byte.SIZE_BITS)) - assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) - assertEquals(value, value.rotateRight(n).rotateRight(-n)) - } - } - - test(0x73, 4, 0x37) - test(0x73, -3, 0x6E) - test(0x73, 1, 0xE6.toByte()) - test(0xE6.toByte(), 1, 0xCD.toByte()) - repeat(100) { - testCyclic(Random.nextInt().toByte()) - } - } - - @Test - fun longRotate() { - fun test(value: Long, n: Int, expected: Long) { - assertEquals(expected, value.rotateLeft(n)) - assertEquals(expected, value.rotateRight(-n)) - } - - fun testCyclic(value: Long) { - for (n in -2 * Long.SIZE_BITS..2 * Long.SIZE_BITS) { - val rl = value.rotateLeft(n) - val rr = value.rotateRight(-n) - assertEquals(rl, rr) - assertEquals(rl, value.rotateLeft(n % Long.SIZE_BITS)) - assertEquals(rr, value.rotateRight((-n) % Long.SIZE_BITS)) - assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) - assertEquals(value, value.rotateRight(n).rotateRight(-n)) - } - } - - test(0x7372ABAC_DEEF0123, 4, 0x372ABAC_DEEF01237) - test(0x88888888_44444444U.toLong(), -3, 0x91111111_08888888u.toLong()) - test(0x88888888_44444444U.toLong(), 1, 0x11111110_88888889) - repeat(100) { - testCyclic(Random.nextLong()) - } - } - - @Test - fun shortRotate() { - fun test(value: Short, n: Int, expected: Short) { - assertEquals(expected, value.rotateLeft(n)) - assertEquals(expected, value.rotateRight(-n)) - } - - fun testCyclic(value: Short) { - for (n in -2 * Short.SIZE_BITS..2 * Short.SIZE_BITS) { - val rl = value.rotateLeft(n) - val rr = value.rotateRight(-n) - assertEquals(rl, rr) - assertEquals(rl, value.rotateLeft(n % Short.SIZE_BITS)) - assertEquals(rr, value.rotateRight((-n) % Short.SIZE_BITS)) - assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) - assertEquals(value, value.rotateRight(n).rotateRight(-n)) - } - } - - test(0x7361, 4, 0x3617) - test(0x7361, -3, 0b001_0111_0011_0110_0) - test(0x7361, 1, 0b111_0011_0110_0001_0.toShort()) - test(0xE6C2.toShort(), 1, 0b11_0011_0110_0001_01.toShort()) - repeat(100) { - testCyclic(Random.nextInt().toShort()) - } - } - } \ No newline at end of file
diff --git a/libraries/stdlib/test/testUtils.kt b/libraries/stdlib/test/testUtils.kt index 8b16cf2..2ea0a9f 100644 --- a/libraries/stdlib/test/testUtils.kt +++ b/libraries/stdlib/test/testUtils.kt
@@ -23,8 +23,16 @@ } -fun assertArrayContentEquals(expected: ByteArray, actual: ByteArray, message: String? = null) = assertTrue(expected contentEquals actual, message) -fun assertArrayContentEquals(expected: CharArray, actual: CharArray, message: String? = null) = assertTrue(expected contentEquals actual, message) +fun <T> assertArrayContentEquals(expected: Array<out T>, actual: Array<out T>, message: String? = null) = assertTrue(expected contentEquals actual, message) + +fun assertArrayContentEquals(expected: ByteArray, actual: ByteArray, message: String? = null) = assertTrue(expected contentEquals actual, message) +fun assertArrayContentEquals(expected: ShortArray, actual: ShortArray, message: String? = null) = assertTrue(expected contentEquals actual, message) +fun assertArrayContentEquals(expected: IntArray, actual: IntArray, message: String? = null) = assertTrue(expected contentEquals actual, message) +fun assertArrayContentEquals(expected: LongArray, actual: LongArray, message: String? = null) = assertTrue(expected contentEquals actual, message) +fun assertArrayContentEquals(expected: FloatArray, actual: FloatArray, message: String? = null) = assertTrue(expected contentEquals actual, message) +fun assertArrayContentEquals(expected: DoubleArray, actual: DoubleArray, message: String? = null) = assertTrue(expected contentEquals actual, message) +fun assertArrayContentEquals(expected: BooleanArray, actual: BooleanArray, message: String? = null) = assertTrue(expected contentEquals actual, message) +fun assertArrayContentEquals(expected: CharArray, actual: CharArray, message: String? = null) = assertTrue(expected contentEquals actual, message) fun assertArrayContentEquals(expected: UIntArray, actual: UIntArray, message: String? = null) = assertTrue(expected contentEquals actual, message) fun assertArrayContentEquals(expected: ULongArray, actual: ULongArray, message: String? = null) = assertTrue(expected contentEquals actual, message)
diff --git a/libraries/stdlib/test/unsigned/UComparisonsTest.kt b/libraries/stdlib/test/unsigned/UComparisonsTest.kt deleted file mode 100644 index a8fc24b..0000000 --- a/libraries/stdlib/test/unsigned/UComparisonsTest.kt +++ /dev/null
@@ -1,60 +0,0 @@ -/* - * Copyright 2010-2019 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 unsigned - -import kotlin.test.Test -import kotlin.test.expect - -class UComparisonsTest { - - @Test - fun minOf_2() { - expect(1.toUByte()) { minOf(2.toUByte(), 1.toUByte()) } - expect(58.toUShort()) { minOf(58.toUShort(), 32768.toUShort()) } - expect(UInt.MIN_VALUE) { minOf(UInt.MIN_VALUE, UInt.MAX_VALUE) } - expect(42312uL) { minOf(42312uL, 42312uL) } - } - - @Test - fun minOf_3() { - expect(1.toUByte()) { minOf(2.toUByte(), 1.toUByte(), 3.toUByte()) } - expect(55.toUShort()) { minOf(58.toUShort(), 32768.toUShort(), 55.toUShort()) } - expect(UInt.MIN_VALUE) { minOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u) } - expect(42312uL) { minOf(42312uL, 42312uL, 42312uL) } - } - - @Test - fun minOf_vararg() { - expect(1.toUByte()) { minOf(2.toUByte(), 1.toUByte(), 3.toUByte(), 2.toUByte(), 10.toUByte()) } - expect(55.toUShort()) { minOf(58.toUShort(), 32768.toUShort(), 55.toUShort(), 2423.toUShort()) } - expect(UInt.MIN_VALUE) { minOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u, 1000u, (-1).toUInt(), Int.MAX_VALUE.toUInt()) } - expect(42312uL) { minOf(42312uL, 42312uL, 42312uL, 42312uL) } - } - - @Test - fun maxOf_2() { - expect(2.toUByte()) { maxOf(2.toUByte(), 1.toUByte()) } - expect(32768.toUShort()) { maxOf(58.toUShort(), 32768.toUShort()) } - expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE) } - expect(42312uL) { maxOf(42312uL, 42312uL) } - } - - @Test - fun maxOf_3() { - expect(3.toUByte()) { maxOf(2.toUByte(), 1.toUByte(), 3.toUByte()) } - expect(32768.toUShort()) { maxOf(58.toUShort(), 32768.toUShort(), 55.toUShort()) } - expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u) } - expect(42312uL) { maxOf(42312uL, 42312uL, 42312uL) } - } - - @Test - fun maxOf_vararg() { - expect(10.toUByte()) { maxOf(2.toUByte(), 1.toUByte(), 3.toUByte(), 2.toUByte(), 10.toUByte()) } - expect(32768.toUShort()) { maxOf(58.toUShort(), 32768.toUShort(), 55.toUShort(), 2423.toUShort()) } - expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u, 1000u, (-1).toUInt(), Int.MAX_VALUE.toUInt()) } - expect(42312uL) { maxOf(42312uL, 42312uL, 42312uL, 42312uL) } - } -} \ No newline at end of file
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/test/AggregatesTest.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/test/AggregatesTest.kt new file mode 100644 index 0000000..991b8c9 --- /dev/null +++ b/libraries/tools/kotlin-stdlib-gen/src/templates/test/AggregatesTest.kt
@@ -0,0 +1,193 @@ +/* + * 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 templates.test + +import templates.* +import templates.Family.* + +object AggregatesTest : TestTemplateGroupBase() { + + val f_minByOrNull = test("minByOrNull()") { + includeDefault() + include(ArraysOfUnsigned) + } builder { + + body { + """ + assertEquals(null, ${of()}.minByOrNull { it }) + assertEquals(ONE, ${of(1)}.minByOrNull { it }) + assertEquals(TWO, ${of(3, 2)}.minByOrNull { it * it }) + assertEquals(THREE, ${of(3, 2)}.minByOrNull { "a" }) + assertEquals(TWO, ${of(3, 2)}.minByOrNull { it.toString() }) + """ + } + bodyAppend(Iterables, Sequences, ArraysOfObjects, ArraysOfPrimitives) { + """ + assertEquals(THREE, ${of(2, 3)}.minByOrNull { -it }) + """ + } + bodyAppend(Iterables, Sequences, ArraysOfObjects) { + """ + assertEquals('a', $of('a', 'b').minByOrNull { "x${"$"}it" }) + assertEquals("b", $of("b", "abc").minByOrNull { it.length }) + """ + } + + bodyAppend(PrimitiveType.Long) { + """ + assertEquals(2000000000000, longArrayOf(3000000000000, 2000000000000).minByOrNull { it + 1 }) + """ + } + body(PrimitiveType.Boolean) { + """ + assertEquals(false, booleanArrayOf(true, false).minByOrNull { it.toString() }) + assertEquals(true, booleanArrayOf(true, false).minByOrNull { it.toString().length }) + """ + } + body(PrimitiveType.Char) { + """ + assertEquals('a', charArrayOf('a', 'b').minByOrNull { "x${"$"}it" }) + assertEquals('b', charArrayOf('b', 'a').minByOrNull { "${"$"}it".length }) + """ + } + } + + val f_maxByOrNull = test("maxByOrNull()") { + includeDefault() + include(ArraysOfUnsigned) + } builder { + + body { + """ + assertEquals(null, ${of()}.maxByOrNull { it }) + assertEquals(ONE, ${of(1)}.maxByOrNull { it }) + assertEquals(THREE, ${of(3, 2)}.maxByOrNull { it * it }) + assertEquals(THREE, ${of(3, 2)}.maxByOrNull { "a" }) + assertEquals(THREE, ${of(3, 2)}.maxByOrNull { it.toString() }) + """ + } + bodyAppend(Iterables, Sequences, ArraysOfObjects, ArraysOfPrimitives) { + """ + assertEquals(TWO, ${of(2, 3)}.maxByOrNull { -it }) + """ + } + bodyAppend(Iterables, Sequences, ArraysOfObjects) { + """ + assertEquals('b', $of('a', 'b').maxByOrNull { "x${"$"}it" }) + assertEquals("abc", $of("b", "abc").maxByOrNull { it.length }) + """ + } + + bodyAppend(PrimitiveType.Long) { + """ + assertEquals(3000000000000, longArrayOf(3000000000000, 2000000000000).maxByOrNull { it + 1 }) + """ + } + body(PrimitiveType.Boolean) { + """ + assertEquals(true, booleanArrayOf(true, false).maxByOrNull { it.toString() }) + assertEquals(false, booleanArrayOf(true, false).maxByOrNull { it.toString().length }) + """ + } + body(PrimitiveType.Char) { + """ + assertEquals('b', charArrayOf('a', 'b').maxByOrNull { "x${"$"}it" }) + assertEquals('b', charArrayOf('b', 'a').maxByOrNull { "${"$"}it".length }) + """ + } + } + + val f_minWithOrNull = test("minWithOrNull()") { + includeDefault() + include(ArraysOfUnsigned) + exclude(PrimitiveType.Boolean, PrimitiveType.Char) + } builder { + + body { + """ + assertEquals(null, ${of()}.minWithOrNull(naturalOrder())) + assertEquals(ONE, ${of(1)}.minWithOrNull(naturalOrder())) + assertEquals(${literal(4)}, ${of(2, 3, 4)}.minWithOrNull(compareBy { it % ${literal(4)} })) + """ + } + bodyAppend(Iterables, Sequences, ArraysOfObjects) { + """ + assertEquals("a", $of("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) + """ + } + } + + val f_maxWithOrNull = test("maxWithOrNull()") { + includeDefault() + include(ArraysOfUnsigned) + exclude(PrimitiveType.Boolean, PrimitiveType.Char) + } builder { + + body { + """ + assertEquals(null, ${of()}.maxWithOrNull(naturalOrder())) + assertEquals(ONE, ${of(1)}.maxWithOrNull(naturalOrder())) + assertEquals(${literal(3)}, ${of(2, 3, 4)}.maxWithOrNull(compareBy { it % ${literal(4)} })) + """ + } + bodyAppend(Iterables, Sequences, ArraysOfObjects) { + """ + assertEquals("B", $of("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER)) + """ + } + } + + val f_foldIndexed = test("foldIndexed()") { + includeDefault() + include(ArraysOfUnsigned) + exclude(PrimitiveType.Boolean, PrimitiveType.Char) + } builder { + + body { + """ + expect(${literal(8)}) { ${of(1, 2, 3)}.foldIndexed(ZERO) { i, acc, e -> acc + i.to$P() * e } } + expect(10) { ${of(1, 2, 3)}.foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(${literal(15)}) { ${of(1, 2, 3)}.foldIndexed(ONE) { i, acc, e -> acc * (i.to$P() + e) } } + expect(" 0-${toString(1)} 1-${toString(2)} 2-${toString(3)}") { ${of(1, 2, 3)}.foldIndexed("") { i, acc, e -> "${"$"}acc ${"$"}i-${"$"}e" } } + + expect(${literal(42)}) { + val numbers = ${of(1, 2, 3, 4)} + numbers.foldIndexed(ZERO) { index, a, b -> index.to$P() * (a + b) } + } + + expect(ZERO) { + val numbers = ${of()} + numbers.foldIndexed(ZERO) { index, a, b -> index.to$P() * (a + b) } + } + + expect("${toString(1)}${toString(1)}${toString(2)}${toString(3)}${toString(4)}") { + val numbers = ${of(1, 2, 3, 4)} + numbers.map { it.toString() }.foldIndexed("") { index, a, b -> if (index == 0) a + b + b else a + b } + } + """ + } + } + + val f_foldRightIndexed = test("foldRightIndexed()") { + include(Lists, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + exclude(PrimitiveType.Boolean, PrimitiveType.Char) + } builder { + + body { + """ + expect(${literal(8)}) { ${of(1, 2, 3)}.foldRightIndexed(ZERO) { i, e, acc -> acc + i.to$P() * e } } + expect(10) { ${of(1, 2, 3)}.foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(${literal(15)}) { ${of(1, 2, 3)}.foldRightIndexed(ONE) { i, e, acc -> acc * (i.to$P() + e) } } + expect(" 2-${toString(3)} 1-${toString(2)} 0-${toString(1)}") { ${of(1, 2, 3)}.foldRightIndexed("") { i, e, acc -> "${"$"}acc ${"$"}i-${"$"}e" } } + + expect("${toString(1)}${toString(2)}${toString(3)}${toString(4)}3210") { + val numbers = ${of(1, 2, 3, 4)} + numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index } + } + """ + } + } +}
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/test/ArraysTest.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/test/ArraysTest.kt new file mode 100644 index 0000000..e14d404 --- /dev/null +++ b/libraries/tools/kotlin-stdlib-gen/src/templates/test/ArraysTest.kt
@@ -0,0 +1,84 @@ +/* + * 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 templates.test + +import templates.* +import templates.Family.* + +object ArraysTest : TestTemplateGroupBase() { + + val f_copyInto = test("copyInto()") { + include(ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + exclude(PrimitiveType.Boolean) + } builder { + body { + """ + val dest = ${of(1, 2, 3)} + val newValues = ${of(4, 5, 6)} + + newValues.copyInto(dest, 0, 1, 3) + val result1 = ${of(5, 6, 3)} + assertTrue(result1 contentEquals dest, "Copying from newValues: ${"$"}{result1.contentToString()}, ${"$"}{dest.contentToString()}") + + dest.copyInto(dest, 0, 1, 3) + val result2 = ${of(6, 3, 3)} + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${"$"}{result2.contentToString()}, ${"$"}{dest.contentToString()}") + + dest.copyInto(dest, 1, 0, 2) + val result3 = ${of(6, 6, 3)} + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${"$"}{result2.contentToString()}, ${"$"}{dest.contentToString()}") + """ + } + body(PrimitiveType.Char) { + """ + val dest = $of('a', 'b', 'c') + val newValues = $of('e', 'f', 'g') + newValues.copyInto(dest, 0, 1, 3) + + val result1 = $of('f', 'g', 'c') + assertTrue(result1 contentEquals dest, "Copying from newValues: ${"$"}{result1.contentToString()}, ${"$"}{dest.contentToString()}") + + dest.copyInto(dest, 0, 1, 3) + val result2 = $of('g', 'c', 'c') + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${"$"}{result2.contentToString()}, ${"$"}{dest.contentToString()}") + + dest.copyInto(dest, 1, 0, 2) + val result3 = $of('g', 'g', 'c') + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${"$"}{result2.contentToString()}, ${"$"}{dest.contentToString()}") + """ + } + body(ArraysOfObjects) { + """ + val dest = arrayOf("a", "b", "c") + val newValues = arrayOf("e", "f", "g") + newValues.copyInto(dest, 0, 1, 3) + + val result1 = arrayOf("f", "g", "c") + assertTrue(result1 contentEquals dest, "Copying from newValues: ${"$"}{result1.contentToString()}, ${"$"}{dest.contentToString()}") + + dest.copyInto(dest, 0, 1, 3) + val result2 = arrayOf("g", "c", "c") + assertTrue(result2 contentEquals dest, "Overlapping backward copy: ${"$"}{result2.contentToString()}, ${"$"}{dest.contentToString()}") + + dest.copyInto(dest, 1, 0, 2) + val result3 = arrayOf("g", "g", "c") + assertTrue(result3 contentEquals dest, "Overlapping forward copy: ${"$"}{result2.contentToString()}, ${"$"}{dest.contentToString()}") + """ + } + bodyAppend { + """ + for ((start, end) in listOf(-1 to 0, 0 to 4, 4 to 4, 1 to 0, 0 to -1)) { + val bounds = "start: ${"$"}start, end: ${"$"}end" + val ex = assertFails(bounds) { newValues.copyInto(dest, 0, start, end) } + assertTrue(ex is IllegalArgumentException || ex is IndexOutOfBoundsException, "Unexpected exception type: ${"$"}ex") + } + for (destIndex in listOf(-1, 2, 4)) { + assertFailsWith<IndexOutOfBoundsException>("index: ${"$"}destIndex") { newValues.copyInto(dest, destIndex, 0, 2) } + } + """ + } + } +} \ No newline at end of file
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/test/ComparablesTest.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/test/ComparablesTest.kt new file mode 100644 index 0000000..c1fa557 --- /dev/null +++ b/libraries/tools/kotlin-stdlib-gen/src/templates/test/ComparablesTest.kt
@@ -0,0 +1,218 @@ +/* + * 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 templates.test + +import templates.* +import templates.Family.* + +object ComparablesTest : TestTemplateGroupBase() { + + private val Family.sourceFileComparisons: SourceFile + get() = when (this) { + Generic, Primitives -> SourceFile.Comparisons + Unsigned -> SourceFile.UComparisons + else -> error(this) + } + + + val f_minOf_2 = test("minOf_2()") { + include(Generic) + include(Primitives, PrimitiveType.numericPrimitives) + include(Unsigned) + } builder { + sourceFile(f.sourceFileComparisons) + + val p = primitive ?: PrimitiveType.Int + val minOf = if (f == Generic) "minOf<${p.name}>" else "minOf" + body { + """ + expect(${toP(1)}) { $minOf(${toP(2)}, ${toP(1)}) } + expect(${toP(58)}) { $minOf(${toP(58)}, ${toP(126)}) } + expect(${toP(23)}) { $minOf(${p.randomNextFrom(23)}, ${toP(23)}) } + expect(MIN_VALUE) { $minOf(MIN_VALUE, MAX_VALUE) } + expect(MAX_VALUE) { $minOf(MAX_VALUE, MAX_VALUE) } + """ + } + if (p.isFloatingPoint()) { + bodyAppend { + """ + assertEquals(-ZERO, $minOf(ZERO, -ZERO)) + assertEquals(-ZERO, $minOf(-ZERO, ZERO)) + assertEquals(NEGATIVE_INFINITY, $minOf(NEGATIVE_INFINITY, POSITIVE_INFINITY)) + """ + } + } + } + + val f_minOf_3 = test("minOf_3()") { + include(Generic) + include(Primitives, PrimitiveType.numericPrimitives) + include(Unsigned) + } builder { + sourceFile(f.sourceFileComparisons) + + val p = primitive ?: PrimitiveType.Int + val minOf = if (f == Generic) "minOf<${p.name}>" else "minOf" + body { + """ + expect(${toP(1)}) { $minOf(${toP(2)}, ${toP(1)}, ${toP(3)}) } + expect(${toP(55)}) { $minOf(${toP(58)}, ${toP(126)}, ${toP(55)}) } + expect(${toP(23)}) { $minOf(${p.randomNextFrom(23)}, ${toP(23)}, ${p.randomNextFrom(23)}) } + expect(MAX_VALUE) { $minOf(MAX_VALUE, MAX_VALUE, MAX_VALUE) } + """ + } + if (p.isFloatingPoint()) { + bodyAppend { + """ + expect(ZERO) { $minOf(MIN_VALUE, MAX_VALUE, ZERO) } + assertEquals(-ZERO, $minOf(ZERO, -ZERO, -ZERO)) + assertEquals(-ZERO, $minOf(-ZERO, ZERO, ZERO)) + assertEquals(MIN_VALUE, $minOf(POSITIVE_INFINITY, MAX_VALUE, MIN_VALUE)) + """ + } + } else { + bodyAppend { + """ + expect(MIN_VALUE) { $minOf(MIN_VALUE, MAX_VALUE, ZERO) } + """ + } + } + } + + val f_minOf_vararg = test("minOf_vararg()") { + include(Generic) + include(Primitives, PrimitiveType.numericPrimitives) + include(Unsigned) + } builder { + sourceFile(f.sourceFileComparisons) + + val p = primitive ?: PrimitiveType.Int + val minOf = if (f == Generic) "minOf<${p.name}>" else "minOf" + body { + """ + expect(${toP(1)}) { $minOf(${toP(2)}, ${toP(1)}, ${toP(3)}, ${toP(10)}) } + expect(${toP(55)}) { $minOf(${toP(58)}, ${toP(126)}, ${toP(55)}, ${toP(87)}) } + expect(${toP(21)}) { $minOf(${p.randomNextFrom(23)}, ${toP(23)}, ${p.randomNextFrom(23)}, ${toP(21)}) } + expect(MAX_VALUE) { $minOf(MAX_VALUE, MAX_VALUE, MAX_VALUE, MAX_VALUE) } + """ + } + if (p.isFloatingPoint()) { + bodyAppend { + """ + assertEquals(ZERO, $minOf(MIN_VALUE, MAX_VALUE, ${toP(0)}, ${toP(1)})) + assertEquals(-ZERO, $minOf(ZERO, -ZERO, -ZERO, ZERO)) + assertEquals(-ZERO, $minOf(-ZERO, ZERO, ZERO, -ZERO)) + assertEquals(NEGATIVE_INFINITY, $minOf(POSITIVE_INFINITY, NEGATIVE_INFINITY, MAX_VALUE, MIN_VALUE)) + """ + } + } else { + bodyAppend { + """ + assertEquals(MIN_VALUE, $minOf(MIN_VALUE, MAX_VALUE, ${toP(0)}, ${toP(1)})) + """ + } + } + } + + val f_maxOf_2 = test("maxOf_2()") { + include(Generic) + include(Primitives, PrimitiveType.numericPrimitives) + include(Unsigned) + } builder { + sourceFile(f.sourceFileComparisons) + + val p = primitive ?: PrimitiveType.Int + val maxOf = if (f == Generic) "maxOf<${p.name}>" else "maxOf" + body { + """ + expect(${toP(2)}) { $maxOf(${toP(2)}, ${toP(1)}) } + expect(${toP(126)}) { $maxOf(${toP(58)}, ${toP(126)}) } + expect(${toP(23)}) { $maxOf(${p.randomNextUntil(23)}, ${toP(23)}) } + expect(MAX_VALUE) { $maxOf(MIN_VALUE, MAX_VALUE) } + expect(MIN_VALUE) { $maxOf(MIN_VALUE, MIN_VALUE) } + """ + } + if (p.isFloatingPoint()) { + bodyAppend { + """ + assertEquals(ZERO, $maxOf(ZERO, -ZERO)) + assertEquals(ZERO, $maxOf(-ZERO, ZERO)) + assertEquals(POSITIVE_INFINITY, $maxOf(NEGATIVE_INFINITY, POSITIVE_INFINITY)) + """ + } + } + } + + val f_maxOf_3 = test("maxOf_3()") { + include(Generic) + include(Primitives, PrimitiveType.numericPrimitives) + include(Unsigned) + } builder { + sourceFile(f.sourceFileComparisons) + + val p = primitive ?: PrimitiveType.Int + val maxOf = if (f == Generic) "maxOf<${p.name}>" else "maxOf" + body { + """ + expect(${toP(3)}) { $maxOf(${toP(2)}, ${toP(1)}, ${toP(3)}) } + expect(${toP(126)}) { $maxOf(${toP(58)}, ${toP(126)}, ${toP(55)}) } + expect(${toP(23)}) { $maxOf(${p.randomNextUntil(23)}, ${toP(23)}, ${p.randomNextUntil(23)}) } + expect(MIN_VALUE) { $maxOf(MIN_VALUE, MIN_VALUE, MIN_VALUE) } + """ + } + if (p.isFloatingPoint()) { + bodyAppend { + """ + expect(MAX_VALUE) { $maxOf(MIN_VALUE, MAX_VALUE, ${toP(0)}) } + assertEquals(ZERO, $maxOf(ZERO, -ZERO, -ZERO)) + assertEquals(ZERO, $maxOf(-ZERO, ZERO, ZERO)) + assertEquals(POSITIVE_INFINITY, $maxOf(POSITIVE_INFINITY, MAX_VALUE, MIN_VALUE)) + """ + } + } else { + bodyAppend { + """ + expect(MAX_VALUE) { $maxOf(MIN_VALUE, MAX_VALUE, ${toP(0)}) } + """ + } + } + } + + val f_maxOf_vararg = test("maxOf_vararg()") { + include(Generic) + include(Primitives, PrimitiveType.numericPrimitives) + include(Unsigned) + } builder { + sourceFile(f.sourceFileComparisons) + + val p = primitive ?: PrimitiveType.Int + val maxOf = if (f == Generic) "maxOf<${p.name}>" else "maxOf" + body { + """ + expect(${toP(10)}) { $maxOf(${toP(2)}, ${toP(1)}, ${toP(3)}, ${toP(10)}) } + expect(${toP(126)}) { $maxOf(${toP(58)}, ${toP(126)}, ${toP(55)}, ${toP(87)}) } + expect(${toP(23)}) { $maxOf(${p.randomNextUntil(23)}, ${toP(23)}, ${p.randomNextUntil(23)}, ${toP(21)}) } + expect(MIN_VALUE) { $maxOf(MIN_VALUE, MIN_VALUE, MIN_VALUE, MIN_VALUE) } + """ + } + if (p.isFloatingPoint()) { + bodyAppend { + """ + expect(MAX_VALUE) { $maxOf(MIN_VALUE, MAX_VALUE, ${toP(0)}, ${toP(1)}) } + assertEquals(ZERO, $maxOf(ZERO, -ZERO, -ZERO, ZERO)) + assertEquals(ZERO, $maxOf(-ZERO, ZERO, ZERO, -ZERO)) + assertEquals(POSITIVE_INFINITY, $maxOf(POSITIVE_INFINITY, NEGATIVE_INFINITY, MAX_VALUE, MIN_VALUE)) + """ + } + } else { + bodyAppend { + """ + expect(MAX_VALUE) { $maxOf(MIN_VALUE, MAX_VALUE, ${toP(0)}, ${toP(1)}) } + """ + } + } + } +} \ No newline at end of file
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/test/ElementsTest.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/test/ElementsTest.kt new file mode 100644 index 0000000..8ddfd4c --- /dev/null +++ b/libraries/tools/kotlin-stdlib-gen/src/templates/test/ElementsTest.kt
@@ -0,0 +1,88 @@ +/* + * 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 templates.test + +import templates.* +import templates.Family.* + +object ElementsTest : TestTemplateGroupBase() { + + val f_indexOf = test("indexOf()") { + include(Lists, Sequences, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + } builder { + specialFor(ArraysOfPrimitives) { + if (primitive!!.isFloatingPoint()) annotation("""@Suppress("DEPRECATION")""") + } + body { + """ + expect(-1) { ${of(1, 2, 3)}.indexOf(ZERO) } + expect(0) { ${of(1, 2, 3)}.indexOf(ONE) } + expect(1) { ${of(1, 2, 3)}.indexOf(TWO) } + expect(2) { ${of(1, 2, 3)}.indexOf(THREE) } + """ + } + bodyAppend(Iterables, Sequences, ArraysOfObjects, Lists) { + """ + expect(-1) { $of("cat", "dog", "bird").indexOf("mouse") } + expect(0) { $of("cat", "dog", "bird").indexOf("cat") } + expect(1) { $of("cat", "dog", "bird").indexOf("dog") } + expect(2) { $of("cat", "dog", "bird").indexOf("bird") } + expect(0) { $of(null, "dog", null).indexOf(null as String?)} + """ + } + body(PrimitiveType.Char) { + """ + expect(-1) { charArrayOf('a', 'b', 'c').indexOf('z') } + expect(0) { charArrayOf('a', 'b', 'c').indexOf('a') } + expect(1) { charArrayOf('a', 'b', 'c').indexOf('b') } + expect(2) { charArrayOf('a', 'b', 'c').indexOf('c') } + """ + } + body(PrimitiveType.Boolean) { + """ + expect(0) { booleanArrayOf(true, false).indexOf(true) } + expect(1) { booleanArrayOf(true, false).indexOf(false) } + expect(-1) { booleanArrayOf(true).indexOf(false) } + """ + } + } + + val f_indexOfFirst = test("indexOfFirst()") { + include(Lists, Sequences, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + } builder { + body { + """ + expect(-1) { ${of(1, 2, 3)}.indexOfFirst { it == ${toP(0)} } } + expect(0) { ${of(1, 2, 3)}.indexOfFirst { it % TWO == ONE } } + expect(1) { ${of(1, 2, 3)}.indexOfFirst { it % TWO == ZERO } } + expect(2) { ${of(1, 2, 3)}.indexOfFirst { it == ${toP(3)} } } + """ + } + bodyAppend(Iterables, Sequences, ArraysOfObjects, Lists) { + """ + expect(-1) { $of("cat", "dog", "bird").indexOfFirst { it.contains("p") } } + expect(0) { $of("cat", "dog", "bird").indexOfFirst { it.startsWith('c') } } + expect(1) { $of("cat", "dog", "bird").indexOfFirst { it.startsWith('d') } } + expect(2) { $of("cat", "dog", "bird").indexOfFirst { it.endsWith('d') } } + """ + } + body(PrimitiveType.Char) { + """ + expect(-1) { charArrayOf('a', 'b', 'c').indexOfFirst { it == 'z' } } + expect(0) { charArrayOf('a', 'b', 'c').indexOfFirst { it < 'c' } } + expect(1) { charArrayOf('a', 'b', 'c').indexOfFirst { it > 'a' } } + expect(2) { charArrayOf('a', 'b', 'c').indexOfFirst { it != 'a' && it != 'b' } } + """ + } + body(PrimitiveType.Boolean) { + """ + expect(0) { booleanArrayOf(true, false, false, true).indexOfFirst { it } } + expect(1) { booleanArrayOf(true, false, false, true).indexOfFirst { !it } } + expect(-1) { booleanArrayOf(true, true).indexOfFirst { !it } } + """ + } + } +} \ No newline at end of file
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/test/NumbersTest.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/test/NumbersTest.kt new file mode 100644 index 0000000..2342841 --- /dev/null +++ b/libraries/tools/kotlin-stdlib-gen/src/templates/test/NumbersTest.kt
@@ -0,0 +1,182 @@ +/* + * 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 templates.test + +import templates.* +import templates.Family.* + +object NumbersTest : TestTemplateGroupBase() { + val f_rotate = test("rotate()") { + include(Primitives, setOf(PrimitiveType.Byte, PrimitiveType.Short, PrimitiveType.Int, PrimitiveType.Long)) + include(Unsigned) + } builder { + body { + """ + fun test(value: $P, n: Int, expected: $P) { + assertEquals(expected, value.rotateLeft(n)) + assertEquals(expected, value.rotateRight(-n)) + } + + fun testCyclic(value: $P) { + for (n in -2 * $P.SIZE_BITS..2 * $P.SIZE_BITS) { + val rl = value.rotateLeft(n) + val rr = value.rotateRight(-n) + assertEquals(rl, rr) + assertEquals(rl, value.rotateLeft(n % $P.SIZE_BITS)) + assertEquals(rr, value.rotateRight((-n) % $P.SIZE_BITS)) + assertEquals(value, value.rotateLeft(n).rotateLeft(-n)) + assertEquals(value, value.rotateRight(n).rotateRight(-n)) + } + } + """ + } + bodyAppend(PrimitiveType.Byte) { + """ + test(0x73, 4, 0x37) + test(0x73, -3, 0x6E) + test(0x73, 1, 0xE6.toByte()) + test(0xE6.toByte(), 1, 0xCD.toByte()) + """ + } + bodyAppend(PrimitiveType.Short) { + """ + test(0x7361, 4, 0x3617) + test(0x7361, -3, 0b001_0111_0011_0110_0) + test(0x7361, 1, 0b111_0011_0110_0001_0.toShort()) + test(0xE6C2.toShort(), 1, 0b11_0011_0110_0001_01.toShort()) + """ + } + bodyAppend(PrimitiveType.Int) { + """ + test(0x7_3422345, 4, 0x3422345_7) + test(0x7342234_5, -4, 0x5_7342234) + test(0x73422345, 1, 0xE684468A.toInt()) + """ + } + bodyAppend(PrimitiveType.Long) { + """ + test(0x7372ABAC_DEEF0123, 4, 0x372ABAC_DEEF01237) + test(0x88888888_44444444U.toLong(), -3, 0x91111111_08888888u.toLong()) + test(0x88888888_44444444U.toLong(), 1, 0x11111110_88888889) + """ + } + bodyAppend(PrimitiveType.UByte) { + """ + test(0x73u, 4, 0x37u) + test(0x73u, -3, 0x6Eu) + test(0x73u, 1, 0xE6u) + test(0xE6u, 1, 0xCDu) + """ + } + bodyAppend(PrimitiveType.UShort) { + """ + test(0x7361u, 4, 0x3617u) + test(0x7361u, -3, 0b001_0111_0011_0110_0u) + test(0x7361u, 1, 0b111_0011_0110_0001_0u) + test(0xE6C2u, 1, 0b11_0011_0110_0001_01u) + """ + } + bodyAppend(PrimitiveType.UInt) { + """ + test(0x7_3422345u, 4, 0x3422345_7u) + test(0x7342234_5u, -4, 0x5_7342234u) + test(0x73422345u, 1, 0xE684468Au) + """ + } + bodyAppend(PrimitiveType.ULong) { + """ + test(0x7372ABAC_DEEF0123uL, 4, 0x372ABAC_DEEF01237uL) + test(0x88888888_44444444uL, -3, 0x91111111_08888888uL) + test(0x88888888_44444444uL, 1, 0x11111110_88888889uL) + """ + } + bodyAppend { + """ + repeat(100) { + testCyclic(${primitive!!.randomNext()}) + } + """ + } + } + + val f_bits = test("bits()") { + include(Primitives, setOf(PrimitiveType.Byte, PrimitiveType.Short, PrimitiveType.Int, PrimitiveType.Long)) + include(Unsigned) + } builder { + body { + val sizeBits = primitive!!.SIZE_BITS + """ + fun test(value: $P, oneBits: Int, leadingZeroes: Int, trailingZeroes: Int) { + assertEquals(oneBits, value.countOneBits()) + assertEquals(leadingZeroes, value.countLeadingZeroBits()) + assertEquals(trailingZeroes, value.countTrailingZeroBits()) + val highestBit = if (leadingZeroes < $P.SIZE_BITS) ONE.shl($P.SIZE_BITS - leadingZeroes - 1).to$P() else ZERO + val lowestBit = if (trailingZeroes < $P.SIZE_BITS) ONE.shl(trailingZeroes).to$P() else ZERO + assertEquals(highestBit, value.takeHighestOneBit()) + assertEquals(lowestBit, value.takeLowestOneBit()) + } + + test(ZERO, 0, $sizeBits, $sizeBits) + test(ONE, 1, ${sizeBits - 1}, 0) + test(TWO, 1, ${sizeBits - 2}, 1) + """ + } + bodyAppend(PrimitiveType.Byte) { + """ + test(0x44, 2, 1, 2) + test(0x80.toByte(), 1, 0, 7) + test(0xF0.toByte(), 4, 0, 4) + """ + } + bodyAppend(PrimitiveType.Short) { + """ + test(0xF2, 5, 8, 1) + test(0x8000.toShort(), 1, 0, 15) + test(0xF200.toShort(), 5, 0, 9) + """ + } + bodyAppend(PrimitiveType.Int) { + """ + test(0xF002, 5, 16, 1) + test(0xF00F0000.toInt(), 8, 0, 16) + """ + } + bodyAppend(PrimitiveType.Long) { + """ + test(0xF002, 5, 48, 1) + test(0xF00F0000L, 8, 32, 16) + test(0x1111_3333_EEEE_0000L, 4 + 8 + 12, 3, 17) + """ + } + bodyAppend(PrimitiveType.UByte) { + """ + test(0x44u, 2, 1, 2) + test(0x80u, 1, 0, 7) + test(0xF0u, 4, 0, 4) + """ + } + bodyAppend(PrimitiveType.UShort) { + """ + test(0xF2u, 5, 8, 1) + test(0x8000u, 1, 0, 15) + test(0xF200u, 5, 0, 9) + """ + } + bodyAppend(PrimitiveType.UInt) { + """ + test(0xF002u, 5, 16, 1) + test(0xF00F0000u, 8, 0, 16) + """ + } + bodyAppend(PrimitiveType.ULong) { + """ + test(0xF002uL, 5, 48, 1) + test(0xF00F0000uL, 8, 32, 16) + test(0x1111_3333_EEEE_0000uL, 4 + 8 + 12, 3, 17) + """ + } + } +} \ No newline at end of file
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/test/OrderingTest.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/test/OrderingTest.kt new file mode 100644 index 0000000..6cf97fc --- /dev/null +++ b/libraries/tools/kotlin-stdlib-gen/src/templates/test/OrderingTest.kt
@@ -0,0 +1,302 @@ +/* + * 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 templates.test + +import templates.* +import templates.Family.* + +object OrderingTest : TestTemplateGroupBase() { + + private val TestBuilder.elementConversion: String + get() = when (primitive) { + null -> "it.toString()" + PrimitiveType.Char -> "'a' + it" + PrimitiveType.Boolean -> "it % 2 == 0" + else -> "it.to${test.P}()" + } + + private val TestBuilder.arrayConversion: String + get() = when (family) { + ArraysOfPrimitives, ArraysOfUnsigned -> "to${test.P}Array()" + else -> "toTypedArray()" + } + + val f_reverse = test("reverse()") { + include(ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + } builder { + body { + """ + val arrays = (0..4).map { n -> (1..n).map { $elementConversion }.$arrayConversion } + for (array in arrays) { + val original = array.toList() + array.reverse() + val reversed = array.toList() + assertEquals(original.asReversed(), reversed) + } + """ + } + } + + val f_reverse_range = test("reverseRange()") { + include(ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + } builder { + body { + """ + val arrays = (0..7).map { n -> n to (0 until n).map { $elementConversion }.$arrayConversion } + for ((size, array) in arrays) { + for (fromIndex in 0 until size) { + for (toIndex in fromIndex..size) { + val original = array.toMutableList() + array.reverse(fromIndex, toIndex) + val reversed = array.toMutableList() + assertEquals(original.apply { subList(fromIndex, toIndex).reverse() }, reversed) + } + } + + assertFailsWith<IndexOutOfBoundsException> { array.reverse(-1, size) } + assertFailsWith<IndexOutOfBoundsException> { array.reverse(0, size + 1) } + assertFailsWith<IllegalArgumentException> { array.reverse(0, -1) } + } + """ + } + } + + val f_reversed = listOf("reversed", "reversedArray").map { op -> + val isReversedArray = op == "reversedArray" + test("$op()") { + include(Iterables, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + filter { family, _ -> (isReversedArray && !family.isArray()).not() } + } builder { + val resultF = if (isReversedArray) f else Lists + body { + "${resultF.assertEquals}(${resultF.of(3, 2, 1)}, ${of(1, 2, 3)}.$op())" + } + bodyAppend(Iterables, ArraysOfObjects) { + """${resultF.assertEquals}(${resultF.of}("3", "2", "1"), $of("1", "2", "3").$op())""" + } + body(PrimitiveType.Char) { + "${resultF.assertEquals}(${resultF.of}('3', '2', '1'), charArrayOf('1', '2', '3').$op())" + } + body(PrimitiveType.Boolean) { + "${resultF.assertEquals}(${resultF.of}(false, false, true), booleanArrayOf(true, false, false).$op())" + } + } + } + + val f_sorted = listOf("sorted", "sortedArray", "sortedDescending", "sortedArrayDescending").map { op -> + val isSortedArray = op.startsWith("sortedArray") + test("$op()") { + includeDefault() + include(ArraysOfUnsigned) + exclude(PrimitiveType.Boolean) + filter { family, _ -> (isSortedArray && !family.isArray()).not() } + } builder { + val cmp = if (op.endsWith("Descending")) ">=" else "<=" + val sortAndCheck = "$op().iterator().assertSorted { a, b -> a.compareTo(b) $cmp 0 }" + body { + """ + ${of(3, 7, 1)}.$sortAndCheck + $of(ONE, MAX_VALUE, MIN_VALUE).$sortAndCheck + """ + } + bodyAppend(Iterables, Sequences, ArraysOfObjects) { + """ + $of("ac", "aD", "aba").$sortAndCheck + """ + } + bodyAppend(PrimitiveType.Float, PrimitiveType.Double) { + """ + $of(POSITIVE_INFINITY, NEGATIVE_INFINITY, MAX_VALUE, -MAX_VALUE, ONE, -ONE, + MIN_VALUE, -MIN_VALUE, ZERO, -ZERO, $P.NaN).$sortAndCheck + """ + } + body(PrimitiveType.Char) { + """ + $of('a', 'D', 'c').$sortAndCheck + """ + } + } + } + + val f_sort = listOf("sort", "sortDescending").map { op -> + val isDescending = op.endsWith("Descending") + test("$op()") { + include(Lists, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + exclude(PrimitiveType.Boolean) + } builder { + val reversed = (if (f.isArray()) ".reversedArray()" else ".reversed()").takeIf { isDescending } ?: "" + body { + val (five, nine, eighty) = listOf(5, 9, 80).map { literal(it) } + """ + val data = $mutableOf($five, TWO, ONE, $nine, $eighty, MIN_VALUE, MAX_VALUE) + data.$op() + $assertEquals($of(MIN_VALUE, ONE, TWO, $five, $nine, $eighty, MAX_VALUE)$reversed, data) + """ + } + bodyAppend(Lists, ArraysOfObjects) { + """ + val strings = $mutableOf("9", "80", "all", "Foo") + strings.$op() + $assertEquals($of("80", "9", "Foo", "all")$reversed, strings) + """ + } + body(PrimitiveType.Char) { + """ + val data = charArrayOf('d', 'c', 'E', 'a', '\u0000', '\uFFFF') + data.$op() + $assertEquals($of('\u0000', 'E', 'a', 'c', 'd', '\uFFFF')$reversed, data) + """ + } + } + } + + val f_sortedWith = listOf("sortedWith", "sortedArrayWith").map { op -> + val isSortedArray = op.contains("Array") + test("$op()") { + includeDefault() + filter { family, _ -> !isSortedArray || family == ArraysOfObjects } + exclude(PrimitiveType.Char, PrimitiveType.Boolean) + } builder { + body { + val sortAndCheck = "$op(comparator).iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 }" + """ + val comparator = compareBy { it: $P -> it % THREE }.thenByDescending { it } + ${of(0, 1, 2, 3, 4, 5)}.$sortAndCheck + """ + } + bodyAppend(Iterables/*, Sequences*/, ArraysOfObjects) { // `.asSequence()` and `object : Sequence { }` are not equal + val resultF = if (isSortedArray || f == Sequences) f else Lists + """ + val comparator1 = compareBy<String> { it.toUpperCase().reversed() } + val data = $of("cat", "dad", "BAD") + + ${resultF.assertEquals}(${resultF.of}("BAD", "dad", "cat"), data.$op(comparator1)) + ${resultF.assertEquals}(${resultF.of}("cat", "dad", "BAD"), data.$op(comparator1.reversed())) + ${resultF.assertEquals}(${resultF.of}("BAD", "dad", "cat"), data.$op(comparator1.reversed().reversed())) + """ + } + } + } + + val f_sortBy = listOf("sortBy", "sortByDescending").map { op -> + val isDescending = op.contains("Descending") + test("$op()") { + include(Lists, ArraysOfObjects) + } builder { + body { + val (bySecond, byFirst, byLength) = if (!isDescending) { + listOf( + """"ab" to 3, "aa" to 3, "aa" to 20""", + """"aa" to 3, "aa" to 20, "ab" to 3""", + """"aa" to 3, "ab" to 3, "aa" to 20""" + ) + } else { + listOf( + """"aa" to 20, "ab" to 3, "aa" to 3""", + """"ab" to 3, "aa" to 20, "aa" to 3""", + """"aa" to 20, "ab" to 3, "aa" to 3""" + ) + } + + """ + val data = $mutableOf("aa" to 20, "ab" to 3, "aa" to 3) + data.$op { it.second } + $assertEquals($of($bySecond), data) + + data.$op { it.first } + $assertEquals($of($byFirst), data) + + data.$op { (it.first + it.second).length } + $assertEquals($of($byLength), data) + """ + } + } + } + + val f_sortedBy = listOf("sortedBy", "sortedByDescending").map { op -> + val isDescending = op.contains("Descending") + test("$op()") { + include(Lists, ArraysOfObjects, ArraysOfPrimitives) + exclude(PrimitiveType.Boolean, PrimitiveType.Char) + } builder { + val resultF = if (f == Sequences) f else Lists + val reversed = if (isDescending) ".reversed()" else "" + body { + """ + val values = arrayOf("ac", "aD", "aba") + val indices = ${of(0, 1, 2)} + + assertEquals(${resultF.of(1, 2, 0)}$reversed, indices.$op { values[it.toInt()] }) + """ + } + bodyAppend(ArraysOfUnsigned) { + """ + val array = $of(5, 2, 1, 9, 80, 0, MAX_VALUE, MAX_VALUE - 100) + assertEquals(listOf<$P>(MAX_VALUE - 100, MAX_VALUE, 0, 1, 2, 5, 9, 80)$reversed, array.$op { it.to${P.drop(1)}() }) + """ + } + bodyAppend(Lists, ArraysOfObjects) { + """ + assertEquals(${resultF.of}("two" to 3, "three" to 20)$reversed, $of("three" to 20, "two" to 3).$op { it.second }) + assertEquals(${resultF.of}("three" to 20, "two" to 3)$reversed, $of("three" to 20, "two" to 3).$op { it.first }) + """ + } + } + } + + + val f_shuffle = test("shuffle()") { + include(Lists, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + } builder { + val type = if (f == Lists) "MutableList" else (primitive?.name ?: "") + "Array" + val typeParam = if (primitive == null) "<*>" else "" + val conversion = if (primitive == PrimitiveType.Boolean) "it % 2 == 0" else "it.to${test.P}()" + body { + """ + fun test(data: $type$typeParam) { + val original = data.toMutableList() + data.shuffle() + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(original.groupBy { it }, shuffled.groupBy { it }) + } + test($type(100) { $conversion }) + """ + } + bodyAppend(Lists, ArraysOfObjects) { + """ + test($mutableOf(1, "x", null, Any(), 'a', 2u, 5.0)) + """ + } + } + + val f_shuffleRandom = test("shuffleRandom()") { + include(Lists, ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned) + } builder { + val type = if (f == Lists) "MutableList" else (primitive?.name ?: "") + "Array" + val typeParam = if (primitive == null) "<*>" else "" + val conversion = if (primitive == PrimitiveType.Boolean) "it % 2 == 0" else "it.to${test.P}()" + body { + """ + fun test(data: $type$typeParam) { + val seed = Random.nextInt() + val original = data.toMutableList() + val originalShuffled = original.shuffled(Random(seed)) + data.shuffle(Random(seed)) + val shuffled = data.toMutableList() + assertNotEquals(original, shuffled) + assertEquals(originalShuffled, shuffled) + } + test($type(16) { $conversion }) + """ + } + bodyAppend(Lists, ArraysOfObjects) { + """ + test($mutableOf(1, "x", null, Any(), 'a', 2u, 5.0)) + """ + } + } +}