From 8a8b204e110aab93116a76be68cbe181b04e966e Mon Sep 17 00:00:00 2001 From: Ilya Chernikov Date: Thu, 16 Feb 2023 12:27:51 +0100 Subject: [PATCH] K2, stdlib tests: make unsigned conversions explicit Allow using K2 to compile stdlib tests related to #KT-56379 --- .../stdlib/test/collections/ArraysTest.kt | 14 +- .../test/collections/UnsignedArraysTest.kt | 651 +++++++++--------- .../test/text/StringNumberConversionTest.kt | 7 +- 3 files changed, 334 insertions(+), 338 deletions(-) diff --git a/libraries/stdlib/test/collections/ArraysTest.kt b/libraries/stdlib/test/collections/ArraysTest.kt index 4c179818122..44e3ece5629 100644 --- a/libraries/stdlib/test/collections/ArraysTest.kt +++ b/libraries/stdlib/test/collections/ArraysTest.kt @@ -3,8 +3,6 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -@file:Suppress("SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED") - package test.collections import test.assertStaticTypeIs @@ -987,20 +985,20 @@ class ArraysTest { 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) + uintArrayOf(1u, 2u, 3u), uintArrayOf(4u, 5u, 6u), + uintArrayOf(5u, 6u, 3u), uintArrayOf(6u, 3u, 3u), uintArrayOf(6u, 6u, 3u) ) 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) + ulongArrayOf(1u, 2u, 3u), ulongArrayOf(4u, 5u, 6u), + ulongArrayOf(5u, 6u, 3u), ulongArrayOf(6u, 3u, 3u), ulongArrayOf(6u, 6u, 3u) ) 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) + ubyteArrayOf(1u, 2u, 3u), ubyteArrayOf(4u, 5u, 6u), + ubyteArrayOf(5u, 6u, 3u), ubyteArrayOf(6u, 3u, 3u), ubyteArrayOf(6u, 6u, 3u) ) } diff --git a/libraries/stdlib/test/collections/UnsignedArraysTest.kt b/libraries/stdlib/test/collections/UnsignedArraysTest.kt index a8f9231fd56..f74d08e207a 100644 --- a/libraries/stdlib/test/collections/UnsignedArraysTest.kt +++ b/libraries/stdlib/test/collections/UnsignedArraysTest.kt @@ -3,7 +3,6 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -@file:Suppress("SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED") package test.collections import test.assertArrayContentEquals @@ -18,9 +17,9 @@ class UnsignedArraysTest { @Test fun collectionBehavior() { compare(listOf(), ubyteArrayOf()) { collectionBehavior() } - compare(listOf(1), ushortArrayOf(1)) { collectionBehavior() } - compare(listOf(1, 2), uintArrayOf(1u, 2u)) { collectionBehavior() } - compare(listOf(1, 2, 3), ulongArrayOf(1u, 2u, 3u)) { collectionBehavior() } + compare(listOf(1u), ushortArrayOf(1u)) { collectionBehavior() } + compare(listOf(1u, 2u), uintArrayOf(1u, 2u)) { collectionBehavior() } + compare(listOf(1u, 2u, 3u), ulongArrayOf(1u, 2u, 3u)) { collectionBehavior() } } @Test @@ -126,7 +125,7 @@ class UnsignedArraysTest { @Test fun asArray() { - val uintArray = uintArrayOf(1, UInt.MAX_VALUE) + val uintArray = uintArrayOf(1u, UInt.MAX_VALUE) val intArray = uintArray.asIntArray() assertTrue(intArray contentEquals intArrayOf(1, -1)) @@ -134,17 +133,17 @@ class UnsignedArraysTest { val uintArray2 = intArray.asUIntArray() assertTrue(uintArray contentEquals uintArray2) - assertTrue(uintArray contentEquals uintArrayOf(UInt.MAX_VALUE, 1)) + assertTrue(uintArray contentEquals uintArrayOf(UInt.MAX_VALUE, 1u)) - val ulongArray = ulongArrayOf(1, ULong.MAX_VALUE) + val ulongArray = ulongArrayOf(1u, ULong.MAX_VALUE) val longArray = ulongArray.asLongArray() assertTrue(longArray contentEquals longArrayOf(1, -1)) longArray.reverse() val ulongArray2 = longArray.asULongArray() assertTrue(ulongArray contentEquals ulongArray2) - assertTrue(ulongArray contentEquals ulongArrayOf(ULong.MAX_VALUE, 1)) + assertTrue(ulongArray contentEquals ulongArrayOf(ULong.MAX_VALUE, 1u)) } @@ -204,15 +203,15 @@ class UnsignedArraysTest { @Test fun copyAndResize() { - assertTrue(uintArrayOf(1, 2) contentEquals uintArrayOf(1, 2, 3).copyOf(2)) - assertTrue(uintArrayOf(1, 2, 0) contentEquals uintArrayOf(1, 2).copyOf(3)) + assertTrue(uintArrayOf(1u, 2u) contentEquals uintArrayOf(1u, 2u, 3u).copyOf(2)) + assertTrue(uintArrayOf(1u, 2u, 0u) contentEquals uintArrayOf(1u, 2u).copyOf(3)) - assertTrue(ulongArrayOf(1, 2) contentEquals ulongArrayOf(1, 2, 3).copyOf(2)) - assertTrue(ulongArrayOf(1, 2, 0) contentEquals ulongArrayOf(1, 2).copyOf(3)) + assertTrue(ulongArrayOf(1u, 2u) contentEquals ulongArrayOf(1u, 2u, 3u).copyOf(2)) + assertTrue(ulongArrayOf(1u, 2u, 0u) contentEquals ulongArrayOf(1u, 2u).copyOf(3)) - assertTrue(uintArrayOf() contentEquals uintArrayOf(1).copyOf(0)) - assertTrue(ulongArrayOf() contentEquals ulongArrayOf(1).copyOf(0)) + assertTrue(uintArrayOf() contentEquals uintArrayOf(1u).copyOf(0)) + assertTrue(ulongArrayOf() contentEquals ulongArrayOf(1u).copyOf(0)) // RuntimeException is the most specific common of JVM and JS implementations assertFailsWith { uintArrayOf().copyOf(-1) } @@ -222,20 +221,20 @@ class UnsignedArraysTest { @Test fun copyOfRange() { - assertTrue(ubyteArrayOf(0, 1, 2) contentEquals ubyteArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3)) - assertTrue(ushortArrayOf(0, 1, 2) contentEquals ushortArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3)) - assertTrue(uintArrayOf(0, 1, 2) contentEquals uintArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3)) - assertTrue(ulongArrayOf(0, 1, 2) contentEquals ulongArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3)) + assertTrue(ubyteArrayOf(0u, 1u, 2u) contentEquals ubyteArrayOf(0u, 1u, 2u, 3u, 4u, 5u).copyOfRange(0, 3)) + assertTrue(ushortArrayOf(0u, 1u, 2u) contentEquals ushortArrayOf(0u, 1u, 2u, 3u, 4u, 5u).copyOfRange(0, 3)) + assertTrue(uintArrayOf(0u, 1u, 2u) contentEquals uintArrayOf(0u, 1u, 2u, 3u, 4u, 5u).copyOfRange(0, 3)) + assertTrue(ulongArrayOf(0u, 1u, 2u) contentEquals ulongArrayOf(0u, 1u, 2u, 3u, 4u, 5u).copyOfRange(0, 3)) for (pos in 0..3) { - assertTrue(uintArrayOf() contentEquals uintArrayOf(1, 2, 3).copyOfRange(pos, pos)) + assertTrue(uintArrayOf() contentEquals uintArrayOf(1u, 2u, 3u).copyOfRange(pos, pos)) assertTrue(ulongArrayOf() contentEquals ULongArray(3) { it.toULong() }.copyOfRange(pos, pos)) } for ((start, end) in listOf(-1 to 0, 0 to 2, 2 to 2, 1 to 0)) { val bounds = "start: $start, end: $end" val exClass = if (start > end) IllegalArgumentException::class else IndexOutOfBoundsException::class - assertFailsWith(exClass, bounds) { uintArrayOf(1).copyOfRange(start, end) } + assertFailsWith(exClass, bounds) { uintArrayOf(1u).copyOfRange(start, end) } assertFailsWith(exClass, bounds) { ulongArrayOf(1uL).copyOfRange(start, end) } } } @@ -249,50 +248,50 @@ class UnsignedArraysTest { @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) } + expect(-1) { ubyteArrayOf(1u, 2u, 3u).indexOf(0u) } + expect(0) { ushortArrayOf(1u, 2u, 3u).indexOf(1u) } + expect(1) { uintArrayOf(1u, 2u, 3u).indexOf(2u) } + expect(2) { ulongArrayOf(1u, 2u, 3u).indexOf(3u) } } @Test fun indexOfFirst() { - expect(-1) { ubyteArrayOf(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() } } + expect(-1) { ubyteArrayOf(1u, 2u, 3u).indexOfFirst { it == 5.toUByte() } } + expect(0) { ushortArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 1u } } + expect(1) { uintArrayOf(1u, 2u, 3u).indexOfFirst { it % 2u == 0u } } + expect(2) { ulongArrayOf(1u, 2u, 3u).indexOfFirst { it == 3.toULong() } } } @Test fun lastIndexOf() { - expect(-1) { ubyteArrayOf(1, 2, 3).lastIndexOf(0) } - expect(0) { ushortArrayOf(1, 2, 3).lastIndexOf(1) } - expect(1) { uintArrayOf(2, 2, 3).lastIndexOf(2) } - expect(2) { ulongArrayOf(3, 2, 3).lastIndexOf(3) } + expect(-1) { ubyteArrayOf(1u, 2u, 3u).lastIndexOf(0u) } + expect(0) { ushortArrayOf(1u, 2u, 3u).lastIndexOf(1u) } + expect(1) { uintArrayOf(2u, 2u, 3u).lastIndexOf(2u) } + expect(2) { ulongArrayOf(3u, 2u, 3u).lastIndexOf(3u) } } @Test fun indexOfLast() { - expect(-1) { ubyteArrayOf(1, 2, 3).indexOfLast { it == 5.toUByte() } } - expect(2) { ushortArrayOf(1, 2, 3).indexOfLast { it % 2u == 1u } } - expect(1) { uintArrayOf(1, 2, 3).indexOfLast { it % 2u == 0u } } - expect(0) { ulongArrayOf(1, 2, 3).indexOfLast { it == 1.toULong() } } + expect(-1) { ubyteArrayOf(1u, 2u, 3u).indexOfLast { it == 5.toUByte() } } + expect(2) { ushortArrayOf(1u, 2u, 3u).indexOfLast { it % 2u == 1u } } + expect(1) { uintArrayOf(1u, 2u, 3u).indexOfLast { it % 2u == 0u } } + expect(0) { ulongArrayOf(1u, 2u, 3u).indexOfLast { it == 1.toULong() } } } @Test fun indices() { expect(0 until 0) { ubyteArrayOf().indices } - expect(0 until 1) { ushortArrayOf(1).indices } - expect(0 until 2) { uintArrayOf(1, 2).indices } - expect(0 until 3) { ulongArrayOf(1, 2, 3).indices } + expect(0 until 1) { ushortArrayOf(1u).indices } + expect(0 until 2) { uintArrayOf(1u, 2u).indices } + expect(0 until 3) { ulongArrayOf(1u, 2u, 3u).indices } } @Test fun lastIndex() { expect(-1) { ubyteArrayOf().lastIndex } - expect(0) { ushortArrayOf(1).lastIndex } - expect(1) { uintArrayOf(1, 2).lastIndex } - expect(2) { ulongArrayOf(1, 2, 3).lastIndex } + expect(0) { ushortArrayOf(1u).lastIndex } + expect(1) { uintArrayOf(1u, 2u).lastIndex } + expect(2) { ulongArrayOf(1u, 2u, 3u).lastIndex } } @Test @@ -330,19 +329,19 @@ class UnsignedArraysTest { @Suppress("DEPRECATION") @Test fun sumBy() { - assertEquals(3u, ubyteArrayOf(0, 1, 2).sumBy { it.toUInt() }) - assertEquals(1u, ushortArrayOf(0, 1, 2).sumBy { it % 2u }) - assertEquals(0u, uintArrayOf(0, 2, 4).sumBy { it % 2u }) - assertEquals(6u, ulongArrayOf(2, 3, 4).sumBy { (it - 1u).toUInt() }) + assertEquals(3u, ubyteArrayOf(0u, 1u, 2u).sumBy { it.toUInt() }) + assertEquals(1u, ushortArrayOf(0u, 1u, 2u).sumBy { it % 2u }) + assertEquals(0u, uintArrayOf(0u, 2u, 4u).sumBy { it % 2u }) + assertEquals(6u, ulongArrayOf(2u, 3u, 4u).sumBy { (it - 1u).toUInt() }) } @Suppress("DEPRECATION") @Test fun sumByDouble() { - assertEquals(3.0, ubyteArrayOf(0, 1, 2).sumByDouble { it.toDouble() }) - assertEquals(1.0, ushortArrayOf(0, 1, 2).sumByDouble { (it % 2u).toDouble() }) - assertEquals(0.0, uintArrayOf(0, 2, 4).sumByDouble { (it % 2u).toDouble() }) - assertEquals(6.0, ulongArrayOf(2, 3, 4).sumByDouble { (it - 1u).toDouble() }) + assertEquals(3.0, ubyteArrayOf(0u, 1u, 2u).sumByDouble { it.toDouble() }) + assertEquals(1.0, ushortArrayOf(0u, 1u, 2u).sumByDouble { (it % 2u).toDouble() }) + assertEquals(0.0, uintArrayOf(0u, 2u, 4u).sumByDouble { (it % 2u).toDouble() }) + assertEquals(6.0, ulongArrayOf(2u, 3u, 4u).sumByDouble { (it - 1u).toDouble() }) } @Test @@ -352,7 +351,7 @@ class UnsignedArraysTest { expect(3) { uintArray.size } assertEquals(uintList, uintArray.toList()) - val genericArray: Array = arrayOf(1, 2, 3) + val genericArray: Array = arrayOf(1u, 2u, 3u) val ulongArray: ULongArray = genericArray.toULongArray() expect(3) { ulongArray.size } assertEquals(genericArray.toList(), ulongArray.toList()) @@ -377,151 +376,151 @@ class UnsignedArraysTest { @Test fun asList() { compare(listOf(), ubyteArrayOf().asList()) { listBehavior() } - compare(listOf(1), ushortArrayOf(1.toUShort()).asList()) { listBehavior() } - compare(listOf(1, 2), uintArrayOf(1u, 2u).asList()) { listBehavior() } - compare(listOf(1, 2, 3), uintArrayOf(1u, 2u, 3u).asList()) { listBehavior() } + compare(listOf(1u), ushortArrayOf(1.toUShort()).asList()) { listBehavior() } + compare(listOf(1u, 2u), uintArrayOf(1u, 2u).asList()) { listBehavior() } + compare(listOf(1u, 2u, 3u), uintArrayOf(1u, 2u, 3u).asList()) { listBehavior() } val ulongs = ulongArrayOf(1uL, 5uL, 7uL) val ulongsAsList = ulongs.asList() assertEquals(5uL, ulongsAsList[1]) - ulongs[1] = 10 + ulongs[1] = 10u assertEquals(10uL, ulongsAsList[1], "Should reflect changes in original array") } @Test fun slice() { - assertEquals(listOf(), uintArrayOf(1, 2, 3).slice(5..1)) - assertEquals(listOf(2, 3, 9), uintArrayOf(2, 3, 9, 2, 3, 9).slice(listOf(3, 1, 2))) - assertEquals(listOf(127, 100), ubyteArrayOf(50, 100, 127).slice(2 downTo 1)) - assertEquals(listOf(200, 100), ushortArrayOf(50, 100, 200).slice(2 downTo 1)) - assertEquals(listOf(100, 200, 30), ulongArrayOf(50, 100, 200, 30).slice(1..3)) + assertEquals(listOf(), uintArrayOf(1u, 2u, 3u).slice(5..1)) + assertEquals(listOf(2u, 3u, 9u), uintArrayOf(2u, 3u, 9u, 2u, 3u, 9u).slice(listOf(3, 1, 2))) + assertEquals(listOf(127u, 100u), ubyteArrayOf(50u, 100u, 127u).slice(2 downTo 1)) + assertEquals(listOf(200u, 100u), ushortArrayOf(50u, 100u, 200u).slice(2 downTo 1)) + assertEquals(listOf(100u, 200u, 30u), ulongArrayOf(50u, 100u, 200u, 30u).slice(1..3)) for (range in listOf(-1 until 0, 0 until 2, 2..2)) { val bounds = "range: $range" val exClass = IndexOutOfBoundsException::class - assertFailsWith(exClass, bounds) { uintArrayOf(1).slice(range) } - assertFailsWith(exClass, bounds) { ulongArrayOf(1).slice(range) } + assertFailsWith(exClass, bounds) { uintArrayOf(1u).slice(range) } + assertFailsWith(exClass, bounds) { ulongArrayOf(1u).slice(range) } } } @Test fun sliceArray() { - assertArrayContentEquals(uintArrayOf(), uintArrayOf(1, 2, 3).sliceArray(5..1)) - assertArrayContentEquals(uintArrayOf(2, 3, 9), uintArrayOf(2, 3, 9, 2, 3, 9).sliceArray(listOf(3, 1, 2))) - assertArrayContentEquals(ubyteArrayOf(127, 100), ubyteArrayOf(50, 100, 127).sliceArray(listOf(2, 1))) - assertArrayContentEquals(ushortArrayOf(200, 100), ushortArrayOf(50, 100, 200).sliceArray(listOf(2, 1))) - assertArrayContentEquals(ulongArrayOf(100, 200, 30), ulongArrayOf(50, 100, 200, 30).sliceArray(1..3)) + assertArrayContentEquals(uintArrayOf(), uintArrayOf(1u, 2u, 3u).sliceArray(5..1)) + assertArrayContentEquals(uintArrayOf(2u, 3u, 9u), uintArrayOf(2u, 3u, 9u, 2u, 3u, 9u).sliceArray(listOf(3, 1, 2))) + assertArrayContentEquals(ubyteArrayOf(127u, 100u), ubyteArrayOf(50u, 100u, 127u).sliceArray(listOf(2, 1))) + assertArrayContentEquals(ushortArrayOf(200u, 100u), ushortArrayOf(50u, 100u, 200u).sliceArray(listOf(2, 1))) + assertArrayContentEquals(ulongArrayOf(100u, 200u, 30u), ulongArrayOf(50u, 100u, 200u, 30u).sliceArray(1..3)) for (range in listOf(-1 until 0, 0 until 2, 2..2)) { val bounds = "range: $range" val exClass = IndexOutOfBoundsException::class - assertFailsWith(exClass, bounds) { ubyteArrayOf(1).sliceArray(range) } - assertFailsWith(exClass, bounds) { ushortArrayOf(1).sliceArray(range) } + assertFailsWith(exClass, bounds) { ubyteArrayOf(1u).sliceArray(range) } + assertFailsWith(exClass, bounds) { ushortArrayOf(1u).sliceArray(range) } } } @Test fun minOrNull() { expect(null) { arrayOf().minOrNull() } - expect(1u) { arrayOf(1).minOrNull() } - expect(2u) { arrayOf(2, 3).minOrNull() } - expect(2uL) { arrayOf(3, 2).minOrNull() } + expect(1u) { arrayOf(1u).minOrNull() } + expect(2u) { arrayOf(2u, 3u).minOrNull() } + expect(2uL) { arrayOf(3u, 2u).minOrNull() } } @Test fun minOrNullInUnsignedArrays() { expect(null) { ubyteArrayOf().minOrNull() } - expect(1u) { ushortArrayOf(1).minOrNull() } - expect(2u) { uintArrayOf(2, 3).minOrNull() } - expect(2uL) { ulongArrayOf(3, 2).minOrNull() } + expect(1u) { ushortArrayOf(1u).minOrNull() } + expect(2u) { uintArrayOf(2u, 3u).minOrNull() } + expect(2uL) { ulongArrayOf(3u, 2u).minOrNull() } } @Test fun maxOrNull() { expect(null) { arrayOf().maxOrNull() } - expect(1u) { arrayOf(1).maxOrNull() } - expect(3u) { arrayOf(2, 3).maxOrNull() } - expect(3uL) { arrayOf(3, 2).maxOrNull() } + expect(1u) { arrayOf(1u).maxOrNull() } + expect(3u) { arrayOf(2u, 3u).maxOrNull() } + expect(3uL) { arrayOf(3u, 2u).maxOrNull() } } @Test fun maxOrNullInUnsignedArrays() { expect(null) { ubyteArrayOf().maxOrNull() } - expect(1u) { ushortArrayOf(1).maxOrNull() } - expect(3u) { uintArrayOf(2, 3).maxOrNull() } - expect(3uL) { ulongArrayOf(3, 2).maxOrNull() } + expect(1u) { ushortArrayOf(1u).maxOrNull() } + expect(3u) { uintArrayOf(2u, 3u).maxOrNull() } + expect(3uL) { ulongArrayOf(3u, 2u).maxOrNull() } } @Test fun minWitOrNullh() { expect(null) { arrayOf().minWithOrNull(naturalOrder()) } - expect(1u) { arrayOf(1).minWithOrNull(naturalOrder()) } - expect(2u) { arrayOf(2, 3).minWithOrNull(naturalOrder()) } - expect(2uL) { arrayOf(3, 2).minWithOrNull(naturalOrder()) } + expect(1u) { arrayOf(1u).minWithOrNull(naturalOrder()) } + expect(2u) { arrayOf(2u, 3u).minWithOrNull(naturalOrder()) } + expect(2uL) { arrayOf(3u, 2u).minWithOrNull(naturalOrder()) } } @Test fun minWithOrNullInUnsignedArrays() { expect(null) { ubyteArrayOf().minWithOrNull(reverseOrder()) } - expect(1u) { ushortArrayOf(1).minWithOrNull(reverseOrder()) } - expect(3u) { uintArrayOf(2, 3).minWithOrNull(reverseOrder()) } - expect(3uL) { ulongArrayOf(3, 2).minWithOrNull(reverseOrder()) } + expect(1u) { ushortArrayOf(1u).minWithOrNull(reverseOrder()) } + expect(3u) { uintArrayOf(2u, 3u).minWithOrNull(reverseOrder()) } + expect(3uL) { ulongArrayOf(3u, 2u).minWithOrNull(reverseOrder()) } } @Test fun maxWithOrNull() { expect(null) { arrayOf().maxWithOrNull(naturalOrder()) } - expect(1u) { arrayOf(1).maxWithOrNull(naturalOrder()) } - expect(3u) { arrayOf(2, 3).maxWithOrNull(naturalOrder()) } - expect(3uL) { arrayOf(3, 2).maxWithOrNull(naturalOrder()) } + expect(1u) { arrayOf(1u).maxWithOrNull(naturalOrder()) } + expect(3u) { arrayOf(2u, 3u).maxWithOrNull(naturalOrder()) } + expect(3uL) { arrayOf(3u, 2u).maxWithOrNull(naturalOrder()) } } @Test fun maxWithOrNullInUnsignedArrays() { expect(null) { ubyteArrayOf().maxWithOrNull(reverseOrder()) } - expect(1u) { ushortArrayOf(1).maxWithOrNull(reverseOrder()) } - expect(2u) { uintArrayOf(2, 3).maxWithOrNull(reverseOrder()) } - expect(2uL) { ulongArrayOf(3, 2).maxWithOrNull(reverseOrder()) } + expect(1u) { ushortArrayOf(1u).maxWithOrNull(reverseOrder()) } + expect(2u) { uintArrayOf(2u, 3u).maxWithOrNull(reverseOrder()) } + expect(2uL) { ulongArrayOf(3u, 2u).maxWithOrNull(reverseOrder()) } } @Test fun minByOrNull() { expect(null) { arrayOf().minByOrNull { it * it } } - expect(1u) { arrayOf(1).minByOrNull { it * it } } - expect(2u) { arrayOf(2, 3).minByOrNull { it * it } } - expect(3uL) { arrayOf(3, 2).minByOrNull { it - 3 } } + expect(1u) { arrayOf(1u).minByOrNull { it * it } } + expect(2u) { arrayOf(2u, 3u).minByOrNull { it * it } } + expect(3uL) { arrayOf(3u, 2u).minByOrNull { it - 3u } } } @Test fun minByOrNullInUnsignedArrays() { expect(null) { ubyteArrayOf().minByOrNull { it * it } } - expect(1u) { ushortArrayOf(1).minByOrNull { it * it } } - expect(2u) { uintArrayOf(2, 3).minByOrNull { it * it } } - expect(3uL) { ulongArrayOf(3, 2).minByOrNull { it - 3 } } + expect(1u) { ushortArrayOf(1u).minByOrNull { it * it } } + expect(2u) { uintArrayOf(2u, 3u).minByOrNull { it * it } } + expect(3uL) { ulongArrayOf(3u, 2u).minByOrNull { it - 3u } } } @Test fun maxByOrNull() { - expect(null) { arrayOf().maxByOrNull { it + 1 } } - expect(1u) { arrayOf(1).maxByOrNull { it + 1 } } - expect(2u) { arrayOf(2, 3).maxByOrNull { it - 3 } } - expect(3uL) { arrayOf(3, 2).maxByOrNull { it + 1 } } + expect(null) { arrayOf().maxByOrNull { it + 1u } } + expect(1u) { arrayOf(1u).maxByOrNull { it + 1u } } + expect(2u) { arrayOf(2u, 3u).maxByOrNull { it - 3u } } + expect(3uL) { arrayOf(3u, 2u).maxByOrNull { it + 1u } } } @Test fun maxByOrNullInUnsignedArrays() { - expect(null) { ubyteArrayOf().maxByOrNull { it + 1 } } - expect(1u) { ushortArrayOf(1).maxByOrNull { it + 1 } } - expect(2u) { uintArrayOf(2, 3).maxByOrNull { it - 3 } } - expect(3uL) { ulongArrayOf(3, 2).maxByOrNull { it + 1 } } + expect(null) { ubyteArrayOf().maxByOrNull { it + 1u } } + expect(1u) { ushortArrayOf(1u).maxByOrNull { it + 1u } } + expect(2u) { uintArrayOf(2u, 3u).maxByOrNull { it - 3u } } + expect(3uL) { ulongArrayOf(3u, 2u).maxByOrNull { it + 1u } } } @Test fun reduce() { - expect(0u) { ubyteArrayOf(3, 2, 1).reduce { acc, e -> (acc - e).toUByte() } } - expect(0u) { ushortArrayOf(3, 2, 1).reduce { acc, e -> (acc - e).toUShort() } } - expect((-4).toUInt()) { uintArrayOf(1, 2, 3).reduce { acc, e -> acc - e } } - expect((-4).toULong()) { ulongArrayOf(1, 2, 3).reduce { acc, e -> acc - e } } + expect(0u) { ubyteArrayOf(3u, 2u, 1u).reduce { acc, e -> (acc - e).toUByte() } } + expect(0u) { ushortArrayOf(3u, 2u, 1u).reduce { acc, e -> (acc - e).toUShort() } } + expect((-4).toUInt()) { uintArrayOf(1u, 2u, 3u).reduce { acc, e -> acc - e } } + expect((-4).toULong()) { ulongArrayOf(1u, 2u, 3u).reduce { acc, e -> acc - e } } assertFailsWith { uintArrayOf().reduce { acc, e -> acc + e } @@ -530,20 +529,20 @@ class UnsignedArraysTest { @Test fun reduceOrNull() { - expect(0u) { ubyteArrayOf(3, 2, 1).reduceOrNull { acc, e -> (acc - e).toUByte() } } - expect(0u) { ushortArrayOf(3, 2, 1).reduceOrNull { acc, e -> (acc - e).toUShort() } } - expect((-4).toUInt()) { uintArrayOf(1, 2, 3).reduceOrNull { acc, e -> acc - e } } - expect((-4).toULong()) { ulongArrayOf(1, 2, 3).reduceOrNull { acc, e -> acc - e } } + expect(0u) { ubyteArrayOf(3u, 2u, 1u).reduceOrNull { acc, e -> (acc - e).toUByte() } } + expect(0u) { ushortArrayOf(3u, 2u, 1u).reduceOrNull { acc, e -> (acc - e).toUShort() } } + expect((-4).toUInt()) { uintArrayOf(1u, 2u, 3u).reduceOrNull { acc, e -> acc - e } } + expect((-4).toULong()) { ulongArrayOf(1u, 2u, 3u).reduceOrNull { acc, e -> acc - e } } assertNull(uintArrayOf().reduceOrNull { acc, e -> acc + e }) } @Test fun reduceIndexed() { - expect(1u) { ubyteArrayOf(3, 2, 1).reduceIndexed { index, acc, e -> if (index != 2) (e - acc).toUByte() else e } } - expect(1u) { ushortArrayOf(3, 2, 1).reduceIndexed { index, acc, e -> if (index != 2) (e - acc).toUShort() else e } } - expect(UInt.MAX_VALUE) { uintArrayOf(1, 2, 3).reduceIndexed { index, acc, e -> index.toUInt() + acc - e } } - expect(ULong.MAX_VALUE) { ulongArrayOf(1, 2, 3).reduceIndexed { index, acc, e -> index.toULong() + acc - e } } + expect(1u) { ubyteArrayOf(3u, 2u, 1u).reduceIndexed { index, acc, e -> if (index != 2) (e - acc).toUByte() else e } } + expect(1u) { ushortArrayOf(3u, 2u, 1u).reduceIndexed { index, acc, e -> if (index != 2) (e - acc).toUShort() else e } } + expect(UInt.MAX_VALUE) { uintArrayOf(1u, 2u, 3u).reduceIndexed { index, acc, e -> index.toUInt() + acc - e } } + expect(ULong.MAX_VALUE) { ulongArrayOf(1u, 2u, 3u).reduceIndexed { index, acc, e -> index.toULong() + acc - e } } assertFailsWith { uintArrayOf().reduceIndexed { index, acc, e -> index.toUInt() + e + acc } @@ -552,30 +551,30 @@ class UnsignedArraysTest { @Test fun reduceIndexedOrNull() { - expect(1u) { ubyteArrayOf(3, 2, 1).reduceIndexedOrNull { index, acc, e -> if (index != 2) (e - acc).toUByte() else e } } - expect(1u) { ushortArrayOf(3, 2, 1).reduceIndexedOrNull { index, acc, e -> if (index != 2) (e - acc).toUShort() else e } } - expect(UInt.MAX_VALUE) { uintArrayOf(1, 2, 3).reduceIndexedOrNull { index, acc, e -> index.toUInt() + acc - e } } - expect(ULong.MAX_VALUE) { ulongArrayOf(1, 2, 3).reduceIndexedOrNull { index, acc, e -> index.toULong() + acc - e } } + expect(1u) { ubyteArrayOf(3u, 2u, 1u).reduceIndexedOrNull { index, acc, e -> if (index != 2) (e - acc).toUByte() else e } } + expect(1u) { ushortArrayOf(3u, 2u, 1u).reduceIndexedOrNull { index, acc, e -> if (index != 2) (e - acc).toUShort() else e } } + expect(UInt.MAX_VALUE) { uintArrayOf(1u, 2u, 3u).reduceIndexedOrNull { index, acc, e -> index.toUInt() + acc - e } } + expect(ULong.MAX_VALUE) { ulongArrayOf(1u, 2u, 3u).reduceIndexedOrNull { index, acc, e -> index.toULong() + acc - e } } expect(null, { uintArrayOf().reduceIndexedOrNull { index, acc, e -> index.toUInt() + e + acc } }) } @Test fun reduceRight() { - expect(2u) { ubyteArrayOf(1, 2, 3).reduceRightOrNull { e, acc -> (e - acc).toUByte() } } - expect(2u) { ushortArrayOf(1, 2, 3).reduceRightOrNull { e, acc -> (e - acc).toUShort() } } - expect(2u) { uintArrayOf(1, 2, 3).reduceRightOrNull { e, acc -> e - acc } } - expect(2uL) { ulongArrayOf(1, 2, 3).reduceRightOrNull { e, acc -> e - acc } } + expect(2u) { ubyteArrayOf(1u, 2u, 3u).reduceRightOrNull { e, acc -> (e - acc).toUByte() } } + expect(2u) { ushortArrayOf(1u, 2u, 3u).reduceRightOrNull { e, acc -> (e - acc).toUShort() } } + expect(2u) { uintArrayOf(1u, 2u, 3u).reduceRightOrNull { e, acc -> e - acc } } + expect(2uL) { ulongArrayOf(1u, 2u, 3u).reduceRightOrNull { e, acc -> e - acc } } assertNull(uintArrayOf().reduceRightOrNull { e, acc -> e + acc }) } @Test fun reduceRightOrNull() { - expect(2u) { ubyteArrayOf(1, 2, 3).reduceRight { e, acc -> (e - acc).toUByte() } } - expect(2u) { ushortArrayOf(1, 2, 3).reduceRight { e, acc -> (e - acc).toUShort() } } - expect(2u) { uintArrayOf(1, 2, 3).reduceRight { e, acc -> e - acc } } - expect(2uL) { ulongArrayOf(1, 2, 3).reduceRight { e, acc -> e - acc } } + expect(2u) { ubyteArrayOf(1u, 2u, 3u).reduceRight { e, acc -> (e - acc).toUByte() } } + expect(2u) { ushortArrayOf(1u, 2u, 3u).reduceRight { e, acc -> (e - acc).toUShort() } } + expect(2u) { uintArrayOf(1u, 2u, 3u).reduceRight { e, acc -> e - acc } } + expect(2uL) { ulongArrayOf(1u, 2u, 3u).reduceRight { e, acc -> e - acc } } assertFailsWith { uintArrayOf().reduceRight { e, acc -> e + acc } @@ -584,10 +583,10 @@ class UnsignedArraysTest { @Test fun reduceRightIndexed() { - expect(1u) { ubyteArrayOf(3, 2, 1).reduceRightIndexed { index, e, acc -> if (index != 1) (e - acc).toUByte() else e } } - expect(1u) { ushortArrayOf(3, 2, 1).reduceRightIndexed { index, e, acc -> if (index != 1) (e - acc).toUShort() else e } } - expect(1u) { uintArrayOf(1, 2, 3).reduceRightIndexed { index, e, acc -> index.toUInt() + e - acc } } - expect(1uL) { ulongArrayOf(1, 2, 3).reduceRightIndexed { index, e, acc -> index.toULong() + e - acc } } + expect(1u) { ubyteArrayOf(3u, 2u, 1u).reduceRightIndexed { index, e, acc -> if (index != 1) (e - acc).toUByte() else e } } + expect(1u) { ushortArrayOf(3u, 2u, 1u).reduceRightIndexed { index, e, acc -> if (index != 1) (e - acc).toUShort() else e } } + expect(1u) { uintArrayOf(1u, 2u, 3u).reduceRightIndexed { index, e, acc -> index.toUInt() + e - acc } } + expect(1uL) { ulongArrayOf(1u, 2u, 3u).reduceRightIndexed { index, e, acc -> index.toULong() + e - acc } } assertFailsWith { uintArrayOf().reduceRightIndexed { index, e, acc -> index.toUInt() + e + acc } @@ -596,10 +595,10 @@ class UnsignedArraysTest { @Test fun reduceRightIndexedOrNull() { - expect(1u) { ubyteArrayOf(3, 2, 1).reduceRightIndexedOrNull { index, e, acc -> if (index != 1) (e - acc).toUByte() else e } } - expect(1u) { ushortArrayOf(3, 2, 1).reduceRightIndexedOrNull { index, e, acc -> if (index != 1) (e - acc).toUShort() else e } } - expect(1u) { uintArrayOf(1, 2, 3).reduceRightIndexedOrNull { index, e, acc -> index.toUInt() + e - acc } } - expect(1uL) { ulongArrayOf(1, 2, 3).reduceRightIndexedOrNull { index, e, acc -> index.toULong() + e - acc } } + expect(1u) { ubyteArrayOf(3u, 2u, 1u).reduceRightIndexedOrNull { index, e, acc -> if (index != 1) (e - acc).toUByte() else e } } + expect(1u) { ushortArrayOf(3u, 2u, 1u).reduceRightIndexedOrNull { index, e, acc -> if (index != 1) (e - acc).toUShort() else e } } + expect(1u) { uintArrayOf(1u, 2u, 3u).reduceRightIndexedOrNull { index, e, acc -> index.toUInt() + e - acc } } + expect(1uL) { ulongArrayOf(1u, 2u, 3u).reduceRightIndexedOrNull { index, e, acc -> index.toULong() + e - acc } } expect(null, { uintArrayOf().reduceRightIndexedOrNull { index, e, acc -> index.toUInt() + e + acc } }) } @@ -607,13 +606,13 @@ class UnsignedArraysTest { @Test fun forEach() { var i = 0 - val a = ubyteArrayOf(3, 2, 1) + val a = ubyteArrayOf(3u, 2u, 1u) a.forEach { e -> assertEquals(e, a[i++]) } } @Test fun forEachIndexed() { - val a = ubyteArrayOf(3, 2, 1) + val a = ubyteArrayOf(3u, 2u, 1u) a.forEachIndexed { index, e -> assertEquals(e, a[index]) } } @@ -635,34 +634,34 @@ class UnsignedArraysTest { @Test fun fold() { - expect(6u) { ubyteArrayOf(1, 2, 3).fold(0u) { acc, e -> acc + e } } - expect(13u) { ushortArrayOf(1, 2, 3).fold(1u) { acc, e -> acc + 2u * e } } - expect(6u) { uintArrayOf(1, 2, 3).fold(1u) { acc, e -> acc * e } } - expect("0123") { ulongArrayOf(1, 2, 3).fold("0") { acc, e -> "$acc$e" } } + expect(6u) { ubyteArrayOf(1u, 2u, 3u).fold(0u) { acc, e -> acc + e } } + expect(13u) { ushortArrayOf(1u, 2u, 3u).fold(1u) { acc, e -> acc + 2u * e } } + expect(6u) { uintArrayOf(1u, 2u, 3u).fold(1u) { acc, e -> acc * e } } + expect("0123") { ulongArrayOf(1u, 2u, 3u).fold("0") { acc, e -> "$acc$e" } } } @Test fun foldIndexed() { - expect(8u) { ubyteArrayOf(1, 2, 3).foldIndexed(0u) { i, acc, e -> acc + i.toUByte() * e } } - expect(10) { ushortArrayOf(1, 2, 3).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } - expect(15u) { uintArrayOf(1, 2, 3).foldIndexed(1u) { i, acc, e -> acc * (i.toUInt() + e) } } - expect(" 0-1 1-2 2-3") { ulongArrayOf(1, 2, 3).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } + expect(8u) { ubyteArrayOf(1u, 2u, 3u).foldIndexed(0u) { i, acc, e -> acc + i.toUByte() * e } } + expect(10) { ushortArrayOf(1u, 2u, 3u).foldIndexed(1) { i, acc, e -> acc + i + e.toInt() } } + expect(15u) { uintArrayOf(1u, 2u, 3u).foldIndexed(1u) { i, acc, e -> acc * (i.toUInt() + e) } } + expect(" 0-1 1-2 2-3") { ulongArrayOf(1u, 2u, 3u).foldIndexed("") { i, acc, e -> "$acc $i-$e" } } } @Test fun foldRight() { - expect(6u) { ubyteArrayOf(1, 2, 3).foldRight(0u) { e, acc -> acc + e } } - expect(13u) { ushortArrayOf(1, 2, 3).foldRight(1u) { e, acc -> acc + 2u * e } } - expect(6u) { uintArrayOf(1, 2, 3).foldRight(1u) { e, acc -> acc * e } } - expect("0321") { ulongArrayOf(1, 2, 3).foldRight("0") { e, acc -> "$acc$e" } } + expect(6u) { ubyteArrayOf(1u, 2u, 3u).foldRight(0u) { e, acc -> acc + e } } + expect(13u) { ushortArrayOf(1u, 2u, 3u).foldRight(1u) { e, acc -> acc + 2u * e } } + expect(6u) { uintArrayOf(1u, 2u, 3u).foldRight(1u) { e, acc -> acc * e } } + expect("0321") { ulongArrayOf(1u, 2u, 3u).foldRight("0") { e, acc -> "$acc$e" } } } @Test fun foldRightIndexed() { - expect(8u) { ubyteArrayOf(1, 2, 3).foldRightIndexed(0u) { i, e, acc -> acc + i.toUByte() * e } } - expect(10) { ushortArrayOf(1, 2, 3).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } - expect(15u) { uintArrayOf(1, 2, 3).foldRightIndexed(1u) { i, e, acc -> acc * (i.toUInt() + e) } } - expect(" 2-3 1-2 0-1") { ulongArrayOf(1, 2, 3).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } + expect(8u) { ubyteArrayOf(1u, 2u, 3u).foldRightIndexed(0u) { i, e, acc -> acc + i.toUByte() * e } } + expect(10) { ushortArrayOf(1u, 2u, 3u).foldRightIndexed(1) { i, e, acc -> acc + i + e.toInt() } } + expect(15u) { uintArrayOf(1u, 2u, 3u).foldRightIndexed(1u) { i, e, acc -> acc * (i.toUInt() + e) } } + expect(" 2-3 1-2 0-1") { ulongArrayOf(1u, 2u, 3u).foldRightIndexed("") { i, e, acc -> "$acc $i-$e" } } } @Test @@ -783,19 +782,19 @@ class UnsignedArraysTest { fun associateWithPrimitives() { assertEquals( mapOf(1u to "1", 2u to "2", 3u to "3"), - uintArrayOf(1, 2, 3).associateWith { it.toString() } + uintArrayOf(1u, 2u, 3u).associateWith { it.toString() } ) assertEquals( mapOf(1.toUByte() to "1", 2.toUByte() to "2", 3.toUByte() to "3"), - ubyteArrayOf(1, 2, 3).associateWith { it.toString() } + ubyteArrayOf(1u, 2u, 3u).associateWith { it.toString() } ) assertEquals( mapOf(1.toUShort() to "1", 2.toUShort() to "2", 3.toUShort() to "3"), - ushortArrayOf(1, 2, 3).associateWith { it.toString() } + ushortArrayOf(1u, 2u, 3u).associateWith { it.toString() } ) assertEquals( mapOf(1UL to "1", 2UL to "2", 3UL to "3"), - ulongArrayOf(1, 2, 3).associateWith { it.toString() } + ulongArrayOf(1u, 2u, 3u).associateWith { it.toString() } ) } @@ -804,149 +803,149 @@ class UnsignedArraysTest { val expected = mapOf(1u to "one", 2u to "two", 3u to "three") assertEquals( mapOf(1u to "one", 2u to "2", 3u to "3"), - uintArrayOf(2, 3).associateWithTo(expected.toMutableMap()) { it.toString() } + uintArrayOf(2u, 3u).associateWithTo(expected.toMutableMap()) { it.toString() } ) assertEquals( mapOf(1.toUByte() to "one", 2.toUByte() to "2", 3.toUByte() to "3"), - ubyteArrayOf(2, 3).associateWithTo(expected.mapKeys { it.key.toUByte() }.toMutableMap()) { it.toString() } + ubyteArrayOf(2u, 3u).associateWithTo(expected.mapKeys { it.key.toUByte() }.toMutableMap()) { it.toString() } ) assertEquals( mapOf(1.toUShort() to "one", 2.toUShort() to "2", 3.toUShort() to "3"), - ushortArrayOf(2, 3).associateWithTo(expected.mapKeys { it.key.toUShort() }.toMutableMap()) { it.toString() } + ushortArrayOf(2u, 3u).associateWithTo(expected.mapKeys { it.key.toUShort() }.toMutableMap()) { it.toString() } ) assertEquals( mapOf(1UL to "one", 2UL to "2", 3UL to "3"), - ulongArrayOf(2, 3).associateWithTo(expected.mapKeys { it.key.toULong() }.toMutableMap()) { it.toString() } + ulongArrayOf(2u, 3u).associateWithTo(expected.mapKeys { it.key.toULong() }.toMutableMap()) { it.toString() } ) } @Test fun elementAt() { - expect(0u) { ubyteArrayOf(0, 1, 2).elementAt(0) } - expect(1u) { ushortArrayOf(0, 1, 2).elementAt(1) } - expect(2u) { uintArrayOf(0, 1, 2).elementAt(2) } + expect(0u) { ubyteArrayOf(0u, 1u, 2u).elementAt(0) } + expect(1u) { ushortArrayOf(0u, 1u, 2u).elementAt(1) } + expect(2u) { uintArrayOf(0u, 1u, 2u).elementAt(2) } assertFailsWith { uintArrayOf().elementAt(0) } - assertFailsWith { ulongArrayOf(0, 1, 2).elementAt(-1) } + assertFailsWith { ulongArrayOf(0u, 1u, 2u).elementAt(-1) } } @Test fun elementAtOrElse() { - expect(0u) { ubyteArrayOf(0, 1, 2).elementAtOrElse(0) { UByte.MAX_VALUE } } - expect(UShort.MAX_VALUE) { ushortArrayOf(0, 1, 2).elementAtOrElse(-1) { UShort.MAX_VALUE } } - expect(UInt.MAX_VALUE) { uintArrayOf(0, 1, 2).elementAtOrElse(3) { UInt.MAX_VALUE } } - expect(ULong.MAX_VALUE) { ulongArrayOf(0, 1, 2).elementAtOrElse(100) { ULong.MAX_VALUE } } + expect(0u) { ubyteArrayOf(0u, 1u, 2u).elementAtOrElse(0) { UByte.MAX_VALUE } } + expect(UShort.MAX_VALUE) { ushortArrayOf(0u, 1u, 2u).elementAtOrElse(-1) { UShort.MAX_VALUE } } + expect(UInt.MAX_VALUE) { uintArrayOf(0u, 1u, 2u).elementAtOrElse(3) { UInt.MAX_VALUE } } + expect(ULong.MAX_VALUE) { ulongArrayOf(0u, 1u, 2u).elementAtOrElse(100) { ULong.MAX_VALUE } } } @Test fun elementAtOrNull() { - expect(0u) { ubyteArrayOf(0, 1, 2).elementAtOrNull(0) } - expect(null) { ushortArrayOf(0, 1, 2).elementAtOrNull(-1) } - expect(null) { uintArrayOf(0, 1, 2).elementAtOrNull(3) } - expect(null) { ulongArrayOf(0, 1, 2).elementAtOrNull(100) } + expect(0u) { ubyteArrayOf(0u, 1u, 2u).elementAtOrNull(0) } + expect(null) { ushortArrayOf(0u, 1u, 2u).elementAtOrNull(-1) } + expect(null) { uintArrayOf(0u, 1u, 2u).elementAtOrNull(3) } + expect(null) { ulongArrayOf(0u, 1u, 2u).elementAtOrNull(100) } } @Test fun find() { - expect(0u) { ubyteArrayOf(0, 1, 2).find { it == 0.toUByte() } } - expect(0u) { ushortArrayOf(0, 1, 2).find { it % 2u == 0u } } - expect(1u) { uintArrayOf(0, 1, 2).find { it % 2u == 1u } } - expect(null) { ulongArrayOf(0, 1, 2).find { it == 3uL } } + expect(0u) { ubyteArrayOf(0u, 1u, 2u).find { it == 0.toUByte() } } + expect(0u) { ushortArrayOf(0u, 1u, 2u).find { it % 2u == 0u } } + expect(1u) { uintArrayOf(0u, 1u, 2u).find { it % 2u == 1u } } + expect(null) { ulongArrayOf(0u, 1u, 2u).find { it == 3uL } } } @Test fun findLast() { - expect(0u) { ubyteArrayOf(0, 1, 2).findLast { it == 0.toUByte() } } - expect(2u) { ushortArrayOf(0, 1, 2).findLast { it % 2u == 0u } } - expect(1u) { uintArrayOf(0, 1, 2).findLast { it % 2u == 1u } } - expect(null) { ulongArrayOf(0, 1, 2).findLast { it == 3uL } } + expect(0u) { ubyteArrayOf(0u, 1u, 2u).findLast { it == 0.toUByte() } } + expect(2u) { ushortArrayOf(0u, 1u, 2u).findLast { it % 2u == 0u } } + expect(1u) { uintArrayOf(0u, 1u, 2u).findLast { it % 2u == 1u } } + expect(null) { ulongArrayOf(0u, 1u, 2u).findLast { it == 3uL } } } @Test fun first() { - expect(0u) { ubyteArrayOf(0, 1, 2).first() } - expect(0u) { ushortArrayOf(0, 1, 2).first { it % 2u == 0u } } - expect(1u) { uintArrayOf(0, 1, 2).first { it % 2u == 1u } } + expect(0u) { ubyteArrayOf(0u, 1u, 2u).first() } + expect(0u) { ushortArrayOf(0u, 1u, 2u).first { it % 2u == 0u } } + expect(1u) { uintArrayOf(0u, 1u, 2u).first { it % 2u == 1u } } assertFailsWith { uintArrayOf().first() } - assertFailsWith { ulongArrayOf(0, 1, 2).first { it == 3uL } } + assertFailsWith { ulongArrayOf(0u, 1u, 2u).first { it == 3uL } } } @Test fun firstOrNull() { - expect(0u) { ubyteArrayOf(0, 1, 2).firstOrNull() } - expect(0u) { ushortArrayOf(0, 1, 2).firstOrNull { it % 2u == 0u } } - expect(1u) { uintArrayOf(0, 1, 2).firstOrNull { it % 2u == 1u } } + expect(0u) { ubyteArrayOf(0u, 1u, 2u).firstOrNull() } + expect(0u) { ushortArrayOf(0u, 1u, 2u).firstOrNull { it % 2u == 0u } } + expect(1u) { uintArrayOf(0u, 1u, 2u).firstOrNull { it % 2u == 1u } } expect(null) { uintArrayOf().firstOrNull() } - expect(null) { ulongArrayOf(0, 1, 2).firstOrNull { it == 3uL } } + expect(null) { ulongArrayOf(0u, 1u, 2u).firstOrNull { it == 3uL } } } @Test fun getOrElse() { - expect(0u) { ubyteArrayOf(0, 1, 2).getOrElse(0) { UByte.MAX_VALUE } } - expect(UShort.MAX_VALUE) { ushortArrayOf(0, 1, 2).getOrElse(-1) { UShort.MAX_VALUE } } - expect(UInt.MAX_VALUE) { uintArrayOf(0, 1, 2).getOrElse(3) { UInt.MAX_VALUE } } - expect(ULong.MAX_VALUE) { ulongArrayOf(0, 1, 2).getOrElse(100) { ULong.MAX_VALUE } } + expect(0u) { ubyteArrayOf(0u, 1u, 2u).getOrElse(0) { UByte.MAX_VALUE } } + expect(UShort.MAX_VALUE) { ushortArrayOf(0u, 1u, 2u).getOrElse(-1) { UShort.MAX_VALUE } } + expect(UInt.MAX_VALUE) { uintArrayOf(0u, 1u, 2u).getOrElse(3) { UInt.MAX_VALUE } } + expect(ULong.MAX_VALUE) { ulongArrayOf(0u, 1u, 2u).getOrElse(100) { ULong.MAX_VALUE } } } @Test fun getOrNull() { - expect(0u) { ubyteArrayOf(0, 1, 2).getOrNull(0) } - expect(null) { ushortArrayOf(0, 1, 2).getOrNull(-1) } - expect(null) { uintArrayOf(0, 1, 2).getOrNull(3) } - expect(null) { ulongArrayOf(0, 1, 2).getOrNull(100) } + expect(0u) { ubyteArrayOf(0u, 1u, 2u).getOrNull(0) } + expect(null) { ushortArrayOf(0u, 1u, 2u).getOrNull(-1) } + expect(null) { uintArrayOf(0u, 1u, 2u).getOrNull(3) } + expect(null) { ulongArrayOf(0u, 1u, 2u).getOrNull(100) } } @Test fun last() { - expect(2u) { ubyteArrayOf(0, 1, 2).last() } - expect(2u) { ushortArrayOf(0, 1, 2).last { it % 2u == 0u } } - expect(1u) { uintArrayOf(0, 1, 2).last { it % 2u == 1u } } + expect(2u) { ubyteArrayOf(0u, 1u, 2u).last() } + expect(2u) { ushortArrayOf(0u, 1u, 2u).last { it % 2u == 0u } } + expect(1u) { uintArrayOf(0u, 1u, 2u).last { it % 2u == 1u } } assertFailsWith { uintArrayOf().last() } - assertFailsWith { ulongArrayOf(0, 1, 2).last { it == 3uL } } + assertFailsWith { ulongArrayOf(0u, 1u, 2u).last { it == 3uL } } } @Test fun lastOrNull() { - expect(2u) { ubyteArrayOf(0, 1, 2).lastOrNull() } - expect(2u) { ushortArrayOf(0, 1, 2).lastOrNull { it % 2u == 0u } } - expect(1u) { uintArrayOf(0, 1, 2).lastOrNull { it % 2u == 1u } } + expect(2u) { ubyteArrayOf(0u, 1u, 2u).lastOrNull() } + expect(2u) { ushortArrayOf(0u, 1u, 2u).lastOrNull { it % 2u == 0u } } + expect(1u) { uintArrayOf(0u, 1u, 2u).lastOrNull { it % 2u == 1u } } expect(null) { uintArrayOf().lastOrNull() } - expect(null) { ulongArrayOf(0, 1, 2).lastOrNull { it == 3uL } } + expect(null) { ulongArrayOf(0u, 1u, 2u).lastOrNull { it == 3uL } } } @Test fun single() { - expect(0u) { ubyteArrayOf(0).single() } - expect(2u) { ushortArrayOf(0, 1, 2).single { it == 2.toUShort() } } - expect(1u) { uintArrayOf(0, 1, 2).single { it % 2u == 1u } } + expect(0u) { ubyteArrayOf(0u).single() } + expect(2u) { ushortArrayOf(0u, 1u, 2u).single { it == 2.toUShort() } } + expect(1u) { uintArrayOf(0u, 1u, 2u).single { it % 2u == 1u } } assertFailsWith { uintArrayOf().single() } - assertFailsWith { ulongArrayOf(0, 1, 2).single { it == 3uL } } - assertFailsWith { ulongArrayOf(0, 1, 2).single { it % 2uL == 0uL } } + assertFailsWith { ulongArrayOf(0u, 1u, 2u).single { it == 3uL } } + assertFailsWith { ulongArrayOf(0u, 1u, 2u).single { it % 2uL == 0uL } } } @Test fun singleOrNull() { - expect(0u) { ubyteArrayOf(0).singleOrNull() } - expect(2u) { ushortArrayOf(0, 1, 2).singleOrNull { it == 2.toUShort() } } - expect(1u) { uintArrayOf(0, 1, 2).singleOrNull { it % 2u == 1u } } + expect(0u) { ubyteArrayOf(0u).singleOrNull() } + expect(2u) { ushortArrayOf(0u, 1u, 2u).singleOrNull { it == 2.toUShort() } } + expect(1u) { uintArrayOf(0u, 1u, 2u).singleOrNull { it % 2u == 1u } } expect(null) { uintArrayOf().singleOrNull() } - expect(null) { ulongArrayOf(0, 1, 2).singleOrNull { it % 2uL == 0uL } } + expect(null) { ulongArrayOf(0u, 1u, 2u).singleOrNull { it % 2uL == 0uL } } } @Test fun map() { assertEquals(listOf(), ubyteArrayOf().map { it }) - assertEquals(listOf(1, 2, 3), ushortArrayOf(1, 2, 3).map { it }) - assertEquals(listOf(2, 4, 6), uintArrayOf(1, 2, 3).map { 2u * it }) - assertEquals(listOf(0, 0, 0), ulongArrayOf(1, 2, 3).map { 0uL }) + assertEquals(listOf(1u, 2u, 3u), ushortArrayOf(1u, 2u, 3u).map { it }) + assertEquals(listOf(2u, 4u, 6u), uintArrayOf(1u, 2u, 3u).map { 2u * it }) + assertEquals(listOf(0u, 0u, 0u), ulongArrayOf(1u, 2u, 3u).map { 0uL }) } @Test fun mapIndexed() { assertEquals(listOf(), ubyteArrayOf().mapIndexed { _, e -> e }) - assertEquals(listOf(1, 2, 3), ushortArrayOf(1, 2, 3).mapIndexed { _, e -> e }) - assertEquals(listOf(0, 1, 2), uintArrayOf(1, 2, 3).mapIndexed { index, _ -> index }) - assertEquals(listOf(0, 0, 0), ulongArrayOf(1, 2, 3).mapIndexed { _, _ -> 0 }) + assertEquals(listOf(1u, 2u, 3u), ushortArrayOf(1u, 2u, 3u).mapIndexed { _, e -> e }) + assertEquals(listOf(0, 1, 2), uintArrayOf(1u, 2u, 3u).mapIndexed { index, _ -> index }) + assertEquals(listOf(0, 0, 0), ulongArrayOf(1u, 2u, 3u).mapIndexed { _, _ -> 0 }) } @Test @@ -954,41 +953,41 @@ class UnsignedArraysTest { assertEquals(mapOf(), ubyteArrayOf().groupBy { k -> k }) assertEquals( mapOf( - 1.toUShort() to listOf(1), - 2.toUShort() to listOf(2), - 3.toUShort() to listOf(3) + 1.toUShort() to listOf(1u), + 2.toUShort() to listOf(2u), + 3.toUShort() to listOf(3u) ), - ushortArrayOf(1, 2, 3).groupBy { k -> k } + ushortArrayOf(1u, 2u, 3u).groupBy { k -> k } ) assertEquals( mapOf( 0.toUInt() to listOf("2"), 1.toUInt() to listOf("1", "3") ), - uintArrayOf(1, 2, 3).groupBy({ k -> k % 2 }, { v -> v.toString() }) + uintArrayOf(1u, 2u, 3u).groupBy({ k -> k % 2u }, { v -> v.toString() }) ) assertEquals( mapOf( 0 to listOf(0, 0, 0) ), - ulongArrayOf(1, 2, 3).groupBy({ 0 }, { 0 }) + ulongArrayOf(1u, 2u, 3u).groupBy({ 0 }, { 0 }) ) } @Test fun flatMap() { assertEquals(listOf(), ubyteArrayOf().flatMap { listOf(it) }) - assertEquals(listOf(1, 2, 3), ushortArrayOf(1, 2, 3).flatMap { listOf(it) }) - assertEquals(listOf(1, 1, 2, 2, 3, 3), uintArrayOf(1, 2, 3).flatMap { listOf(it, it) }) - assertEquals(listOf(), ulongArrayOf(1, 2, 3).flatMap { listOf() }) + assertEquals(listOf(1u, 2u, 3u), ushortArrayOf(1u, 2u, 3u).flatMap { listOf(it) }) + assertEquals(listOf(1u, 1u, 2u, 2u, 3u, 3u), uintArrayOf(1u, 2u, 3u).flatMap { listOf(it, it) }) + assertEquals(listOf(), ulongArrayOf(1u, 2u, 3u).flatMap { listOf() }) } @Test fun flatMapIndexed() { assertEquals(listOf(), ubyteArrayOf().flatMapIndexed { index, _ -> listOf(index) }) - assertEquals(listOf(2, 3, 3), ushortArrayOf(1, 2, 3).flatMapIndexed { index, e -> List(index) { e } }) - assertEquals(listOf(2, 2, 3, 3, 3, 3), uintArrayOf(1, 2, 3).flatMapIndexed { index, e -> List(index * 2) { e } }) - assertEquals(listOf(), ulongArrayOf(1, 2, 3).flatMapIndexed { _, _ -> listOf() }) + assertEquals(listOf(2u, 3u, 3u), ushortArrayOf(1u, 2u, 3u).flatMapIndexed { index, e -> List(index) { e } }) + assertEquals(listOf(2u, 2u, 3u, 3u, 3u, 3u), uintArrayOf(1u, 2u, 3u).flatMapIndexed { index, e -> List(index * 2) { e } }) + assertEquals(listOf(), ulongArrayOf(1u, 2u, 3u).flatMapIndexed { _, _ -> listOf() }) } @Test @@ -1004,10 +1003,10 @@ class UnsignedArraysTest { IndexedValue(1, 2.toUShort()), IndexedValue(2, 3.toUShort()) ), - ushortArrayOf(1, 2, 3).withIndex() + ushortArrayOf(1u, 2u, 3u).withIndex() ) - assertEquals(IndexedValue(1, 2.toUInt()), uintArrayOf(1, 2, 3).withIndex().minByOrNull { it.value % 2 }) - assertIterableContentEquals(listOf(0, 1, 2), ulongArrayOf(1, 2, 3).withIndex().map { it.index }) + assertEquals(IndexedValue(1, 2.toUInt()), uintArrayOf(1u, 2u, 3u).withIndex().minByOrNull { it.value % 2u }) + assertIterableContentEquals(listOf(0, 1, 2), ulongArrayOf(1u, 2u, 3u).withIndex().map { it.index }) } @Test @@ -1018,32 +1017,32 @@ class UnsignedArraysTest { 1.toUShort() to 1.toUShort(), 2.toUShort() to 2.toUShort() ), - ushortArrayOf(1, 2, 3).zip(ushortArrayOf(1, 2)) + ushortArrayOf(1u, 2u, 3u).zip(ushortArrayOf(1u, 2u)) ) assertEquals( listOf("1a", "2b", "3c"), - uintArrayOf(1, 2, 3).zip(arrayOf("a", "b", "c", "d")) { a, b -> a.toString() + b } + uintArrayOf(1u, 2u, 3u).zip(arrayOf("a", "b", "c", "d")) { a, b -> a.toString() + b } ) assertEquals( - listOf(11, 12, 13), - ulongArrayOf(1, 2, 3).zip(listOf(10, 10, 10)) { a, b -> a + b } + listOf(11u, 12u, 13u), + ulongArrayOf(1u, 2u, 3u).zip(listOf(10u, 10u, 10u)) { a, b -> a + b } ) } @Test fun onEach() { - assertEquals(listOf(1, 2, 3), mutableListOf().apply { uintArrayOf(1, 2, 3).onEach { add(it) } }) - assertEquals(listOf(1, 2, 3), mutableListOf().apply { ubyteArrayOf(1, 2, 3).onEach { add(it) } }) - assertEquals(listOf(1, 2, 3), mutableListOf().apply { ushortArrayOf(1, 2, 3).onEach { add(it) } }) - assertEquals(listOf(1, 2, 3), mutableListOf().apply { ulongArrayOf(1, 2, 3).onEach { add(it) } }) + assertEquals(listOf(1u, 2u, 3u), mutableListOf().apply { uintArrayOf(1u, 2u, 3u).onEach { add(it) } }) + assertEquals(listOf(1u, 2u, 3u), mutableListOf().apply { ubyteArrayOf(1u, 2u, 3u).onEach { add(it) } }) + assertEquals(listOf(1u, 2u, 3u), mutableListOf().apply { ushortArrayOf(1u, 2u, 3u).onEach { add(it) } }) + assertEquals(listOf(1u, 2u, 3u), mutableListOf().apply { ulongArrayOf(1u, 2u, 3u).onEach { add(it) } }) } @Test fun onEachIndexed() { - assertEquals(listOf(1, 3, 5), mutableListOf().apply { uintArrayOf(1, 2, 3).onEachIndexed { i, e -> add(i.toUInt() + e) } }) - assertEquals(listOf(1, 3, 5), mutableListOf().apply { ubyteArrayOf(1, 2, 3).onEachIndexed { i, e -> add(i.toUByte() + e) } }) - assertEquals(listOf(1, 3, 5), mutableListOf().apply { ushortArrayOf(1, 2, 3).onEachIndexed { i, e -> add(i.toUShort() + e) } }) - assertEquals(listOf(1, 3, 5), mutableListOf().apply { ulongArrayOf(1, 2, 3).onEachIndexed { i, e -> add(i.toULong() + e) } }) + assertEquals(listOf(1u, 3u, 5u), mutableListOf().apply { uintArrayOf(1u, 2u, 3u).onEachIndexed { i, e -> add(i.toUInt() + e) } }) + assertEquals(listOf(1u, 3u, 5u), mutableListOf().apply { ubyteArrayOf(1u, 2u, 3u).onEachIndexed { i, e -> add(i.toUByte() + e) } }) + assertEquals(listOf(1u, 3u, 5u), mutableListOf().apply { ushortArrayOf(1u, 2u, 3u).onEachIndexed { i, e -> add(i.toUShort() + e) } }) + assertEquals(listOf(1u, 3u, 5u), mutableListOf().apply { ulongArrayOf(1u, 2u, 3u).onEachIndexed { i, e -> add(i.toULong() + e) } }) val empty = arrayOf() assertSame(empty, empty.onEachIndexed { i, e -> fail("Should be unreachable: $i, $e") }) @@ -1055,23 +1054,23 @@ class UnsignedArraysTest { @Test fun drop() { - expect(listOf(1.toUByte())) { ubyteArrayOf(1).drop(0) } + expect(listOf(1.toUByte())) { ubyteArrayOf(1u).drop(0) } expect(listOf()) { ushortArrayOf().drop(1) } - expect(listOf()) { uintArrayOf(1).drop(1) } - expect(listOf(3uL)) { ulongArrayOf(2, 3).drop(1) } + expect(listOf()) { uintArrayOf(1u).drop(1) } + expect(listOf(3uL)) { ulongArrayOf(2u, 3u).drop(1) } assertFails { - uintArrayOf(2).drop(-1) + uintArrayOf(2u).drop(-1) } } @Test fun dropLast() { expect(listOf()) { ubyteArrayOf().dropLast(1) } - expect(listOf()) { ushortArrayOf(1).dropLast(1) } - expect(listOf(1u)) { uintArrayOf(1).dropLast(0) } - expect(listOf(2uL)) { ulongArrayOf(2, 3).dropLast(1) } + expect(listOf()) { ushortArrayOf(1u).dropLast(1) } + expect(listOf(1u)) { uintArrayOf(1u).dropLast(0) } + expect(listOf(2uL)) { ulongArrayOf(2u, 3u).dropLast(1) } assertFails { - ulongArrayOf(1).dropLast(-1) + ulongArrayOf(1u).dropLast(-1) } } @@ -1094,22 +1093,22 @@ class UnsignedArraysTest { @Test fun take() { expect(listOf()) { ubyteArrayOf().take(1) } - expect(listOf()) { ushortArrayOf(1).take(0) } - expect(listOf(1u)) { uintArrayOf(1).take(1) } - expect(listOf(2uL)) { ulongArrayOf(2, 3).take(1) } + expect(listOf()) { ushortArrayOf(1u).take(0) } + expect(listOf(1u)) { uintArrayOf(1u).take(1) } + expect(listOf(2uL)) { ulongArrayOf(2u, 3u).take(1) } assertFails { - ubyteArrayOf(1).take(-1) + ubyteArrayOf(1u).take(-1) } } @Test fun takeLast() { expect(listOf()) { ubyteArrayOf().takeLast(1) } - expect(listOf()) { ushortArrayOf(1).takeLast(0) } - expect(listOf(1u)) { uintArrayOf(1).takeLast(1) } - expect(listOf(3uL)) { ulongArrayOf(2, 3).takeLast(1) } + expect(listOf()) { ushortArrayOf(1u).takeLast(0) } + expect(listOf(1u)) { uintArrayOf(1u).takeLast(1) } + expect(listOf(3uL)) { ulongArrayOf(2u, 3u).takeLast(1) } assertFails { - ushortArrayOf(1).takeLast(-1) + ushortArrayOf(1u).takeLast(-1) } } @@ -1163,116 +1162,116 @@ class UnsignedArraysTest { @Test fun sort() { - val ubyteArray = ubyteArrayOf(5, 2, 1, 9, 80, 0, UByte.MAX_VALUE, 250) - assertArrayContentEquals(ubyteArrayOf(0, 1, 2, 5, 9, 80, 250, UByte.MAX_VALUE), ubyteArray.apply { sort() }) + val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u) + assertArrayContentEquals(ubyteArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 250u, UByte.MAX_VALUE), ubyteArray.apply { sort() }) - val ushortArray = ushortArrayOf(5, 2, 1, 9, 80, 0, UShort.MAX_VALUE, 65501) - assertArrayContentEquals(ushortArrayOf(0, 1, 2, 5, 9, 80, 65501, UShort.MAX_VALUE), ushortArray.apply { sort() }) + val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u) + assertArrayContentEquals(ushortArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 65501u, UShort.MAX_VALUE), ushortArray.apply { sort() }) - val uintArray = uintArrayOf(5, 2, 1, 9, 80, 0, UInt.MAX_VALUE, 4294967200) - assertArrayContentEquals(uintArrayOf(0, 1, 2, 5, 9, 80, 4294967200, UInt.MAX_VALUE), uintArray.apply { sort() }) + val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u) + assertArrayContentEquals(uintArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 4294967200u, UInt.MAX_VALUE), uintArray.apply { sort() }) - val ulongArray = ulongArrayOf(5, 2, 1, 9, 80, 0, ULong.MAX_VALUE, ULong.MAX_VALUE - 123) - assertArrayContentEquals(ulongArrayOf(0, 1, 2, 5, 9, 80, ULong.MAX_VALUE - 123, ULong.MAX_VALUE), ulongArray.apply { sort() }) + val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u) + assertArrayContentEquals(ulongArrayOf(0u, 1u, 2u, 5u, 9u, 80u, ULong.MAX_VALUE - 123u, ULong.MAX_VALUE), ulongArray.apply { sort() }) } @Test fun sortDescending() { - val ubyteArray = ubyteArrayOf(5, 2, 1, 9, 80, 0, UByte.MAX_VALUE, 250) - assertArrayContentEquals(ubyteArrayOf(UByte.MAX_VALUE, 250, 80, 9, 5, 2, 1, 0), ubyteArray.apply { sortDescending() }) + val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u) + assertArrayContentEquals(ubyteArrayOf(UByte.MAX_VALUE, 250u, 80u, 9u, 5u, 2u, 1u, 0u), ubyteArray.apply { sortDescending() }) - val ushortArray = ushortArrayOf(5, 2, 1, 9, 80, 0, UShort.MAX_VALUE, 65501) - assertArrayContentEquals(ushortArrayOf(UShort.MAX_VALUE, 65501, 80, 9, 5, 2, 1, 0), ushortArray.apply { sortDescending() }) + val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u) + assertArrayContentEquals(ushortArrayOf(UShort.MAX_VALUE, 65501u, 80u, 9u, 5u, 2u, 1u, 0u), ushortArray.apply { sortDescending() }) - val uintArray = uintArrayOf(5, 2, 1, 9, 80, 0, UInt.MAX_VALUE, 4294967200) - assertArrayContentEquals(uintArrayOf(UInt.MAX_VALUE, 4294967200, 80, 9, 5, 2, 1, 0), uintArray.apply { sortDescending() }) + val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u) + assertArrayContentEquals(uintArrayOf(UInt.MAX_VALUE, 4294967200u, 80u, 9u, 5u, 2u, 1u, 0u), uintArray.apply { sortDescending() }) - val ulongArray = ulongArrayOf(5, 2, 1, 9, 80, 0, ULong.MAX_VALUE, ULong.MAX_VALUE - 123) - assertArrayContentEquals(ulongArrayOf(ULong.MAX_VALUE, ULong.MAX_VALUE - 123, 80, 9, 5, 2, 1, 0), ulongArray.apply { sortDescending() }) + val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u) + assertArrayContentEquals(ulongArrayOf(ULong.MAX_VALUE, ULong.MAX_VALUE - 123u, 80u, 9u, 5u, 2u, 1u, 0u), ulongArray.apply { sortDescending() }) } @Test fun sorted() { assertTrue(uintArrayOf().sorted().none()) - assertEquals(listOf(1u), uintArrayOf(1).sorted()) + assertEquals(listOf(1u), uintArrayOf(1u).sorted()) - val ubyteArray = ubyteArrayOf(5, 2, 1, 9, 80, 0, UByte.MAX_VALUE, 250) - assertEquals(listOf(0, 1, 2, 5, 9, 80, 250, UByte.MAX_VALUE), ubyteArray.sorted()) + val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u) + assertEquals(listOf(0u, 1u, 2u, 5u, 9u, 80u, 250u, UByte.MAX_VALUE), ubyteArray.sorted()) - val ushortArray = ushortArrayOf(5, 2, 1, 9, 80, 0, UShort.MAX_VALUE, 65501) - assertEquals(listOf(0, 1, 2, 5, 9, 80, 65501, UShort.MAX_VALUE), ushortArray.sorted()) + val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u) + assertEquals(listOf(0u, 1u, 2u, 5u, 9u, 80u, 65501u, UShort.MAX_VALUE), ushortArray.sorted()) - val uintArray = uintArrayOf(5, 2, 1, 9, 80, 0, UInt.MAX_VALUE, 4294967200) - assertEquals(listOf(0, 1, 2, 5, 9, 80, 4294967200, UInt.MAX_VALUE), uintArray.sorted()) + val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u) + assertEquals(listOf(0u, 1u, 2u, 5u, 9u, 80u, 4294967200u, UInt.MAX_VALUE), uintArray.sorted()) - val ulongArray = ulongArrayOf(5, 2, 1, 9, 80, 0, ULong.MAX_VALUE, ULong.MAX_VALUE - 123) - assertEquals(listOf(0, 1, 2, 5, 9, 80, ULong.MAX_VALUE - 123, ULong.MAX_VALUE), ulongArray.sorted()) + val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u) + assertEquals(listOf(0u, 1u, 2u, 5u, 9u, 80u, ULong.MAX_VALUE - 123u, ULong.MAX_VALUE), ulongArray.sorted()) } @Test fun sortedDescending() { assertTrue(uintArrayOf().sortedDescending().none()) - assertEquals(listOf(1u), uintArrayOf(1).sortedDescending()) + assertEquals(listOf(1u), uintArrayOf(1u).sortedDescending()) - val ubyteArray = ubyteArrayOf(5, 2, 1, 9, 80, 0, UByte.MAX_VALUE, 250) - assertEquals(listOf(UByte.MAX_VALUE, 250, 80, 9, 5, 2, 1, 0), ubyteArray.sortedDescending()) + val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u) + assertEquals(listOf(UByte.MAX_VALUE, 250u, 80u, 9u, 5u, 2u, 1u, 0u), ubyteArray.sortedDescending()) - val ushortArray = ushortArrayOf(5, 2, 1, 9, 80, 0, UShort.MAX_VALUE, 65501) - assertEquals(listOf(UShort.MAX_VALUE, 65501, 80, 9, 5, 2, 1, 0), ushortArray.sortedDescending()) + val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u) + assertEquals(listOf(UShort.MAX_VALUE, 65501u, 80u, 9u, 5u, 2u, 1u, 0u), ushortArray.sortedDescending()) - val uintArray = uintArrayOf(5, 2, 1, 9, 80, 0, UInt.MAX_VALUE, 4294967200) - assertEquals(listOf(UInt.MAX_VALUE, 4294967200, 80, 9, 5, 2, 1, 0), uintArray.sortedDescending()) + val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u) + assertEquals(listOf(UInt.MAX_VALUE, 4294967200u, 80u, 9u, 5u, 2u, 1u, 0u), uintArray.sortedDescending()) - val ulongArray = ulongArrayOf(5, 2, 1, 9, 80, 0, ULong.MAX_VALUE, ULong.MAX_VALUE - 123) - assertEquals(listOf(ULong.MAX_VALUE, ULong.MAX_VALUE - 123, 80, 9, 5, 2, 1, 0), ulongArray.sortedDescending()) + val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u) + assertEquals(listOf(ULong.MAX_VALUE, ULong.MAX_VALUE - 123u, 80u, 9u, 5u, 2u, 1u, 0u), ulongArray.sortedDescending()) } @Test fun sortedBy() { assertTrue(uintArrayOf().sortedBy { it.toString() }.none()) - assertEquals(listOf(1u), uintArrayOf(1).sortedBy { it.toString() }) + assertEquals(listOf(1u), uintArrayOf(1u).sortedBy { it.toString() }) - val ubyteArray = ubyteArrayOf(5, 2, 1, 9, 80, 0, UByte.MAX_VALUE, 250) - assertEquals(listOf(250, UByte.MAX_VALUE, 0, 1, 2, 5, 9, 80), ubyteArray.sortedBy { it.toByte() }) + val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u) + assertEquals(listOf(250u, UByte.MAX_VALUE, 0u, 1u, 2u, 5u, 9u, 80u), ubyteArray.sortedBy { it.toByte() }) - val ushortArray = ushortArrayOf(5, 2, 1, 9, 80, 0, UShort.MAX_VALUE, 65501) - assertEquals(listOf(65501, UShort.MAX_VALUE, 0, 1, 2, 5, 9, 80), ushortArray.sortedBy { it.toShort() }) + val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u) + assertEquals(listOf(65501u, UShort.MAX_VALUE, 0u, 1u, 2u, 5u, 9u, 80u), ushortArray.sortedBy { it.toShort() }) - val uintArray = uintArrayOf(5, 2, 1, 9, 80, 0, UInt.MAX_VALUE, 4294967200) - assertEquals(listOf(4294967200, UInt.MAX_VALUE, 0, 1, 2, 5, 9, 80), uintArray.sortedBy { it.toInt() }) + val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u) + assertEquals(listOf(4294967200u, UInt.MAX_VALUE, 0u, 1u, 2u, 5u, 9u, 80u), uintArray.sortedBy { it.toInt() }) - val ulongArray = ulongArrayOf(5, 2, 1, 9, 80, 0, ULong.MAX_VALUE, ULong.MAX_VALUE - 123) - assertEquals(listOf(ULong.MAX_VALUE - 123, ULong.MAX_VALUE, 0, 1, 2, 5, 9, 80), ulongArray.sortedBy { it.toLong() }) + val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u) + assertEquals(listOf(ULong.MAX_VALUE - 123u, ULong.MAX_VALUE, 0u, 1u, 2u, 5u, 9u, 80u), ulongArray.sortedBy { it.toLong() }) } @Test fun sortedArray() { - val ubyteArray = ubyteArrayOf(5, 2, 1, 9, 80, 0, UByte.MAX_VALUE, 250) - assertArrayContentEquals(ubyteArrayOf(0, 1, 2, 5, 9, 80, 250, UByte.MAX_VALUE), ubyteArray.sortedArray()) + val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u) + assertArrayContentEquals(ubyteArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 250u, UByte.MAX_VALUE), ubyteArray.sortedArray()) - val ushortArray = ushortArrayOf(5, 2, 1, 9, 80, 0, UShort.MAX_VALUE, 65501) - assertArrayContentEquals(ushortArrayOf(0, 1, 2, 5, 9, 80, 65501, UShort.MAX_VALUE), ushortArray.sortedArray()) + val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u) + assertArrayContentEquals(ushortArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 65501u, UShort.MAX_VALUE), ushortArray.sortedArray()) - val uintArray = uintArrayOf(5, 2, 1, 9, 80, 0, UInt.MAX_VALUE, 4294967200) - assertArrayContentEquals(uintArrayOf(0, 1, 2, 5, 9, 80, 4294967200, UInt.MAX_VALUE), uintArray.sortedArray()) + val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u) + assertArrayContentEquals(uintArrayOf(0u, 1u, 2u, 5u, 9u, 80u, 4294967200u, UInt.MAX_VALUE), uintArray.sortedArray()) - val ulongArray = ulongArrayOf(5, 2, 1, 9, 80, 0, ULong.MAX_VALUE, ULong.MAX_VALUE - 123) - assertArrayContentEquals(ulongArrayOf(0, 1, 2, 5, 9, 80, ULong.MAX_VALUE - 123, ULong.MAX_VALUE), ulongArray.sortedArray()) + val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u) + assertArrayContentEquals(ulongArrayOf(0u, 1u, 2u, 5u, 9u, 80u, ULong.MAX_VALUE - 123u, ULong.MAX_VALUE), ulongArray.sortedArray()) } @Test fun sortedArrayDescending() { - val ubyteArray = ubyteArrayOf(5, 2, 1, 9, 80, 0, UByte.MAX_VALUE, 250) - assertArrayContentEquals(ubyteArrayOf(UByte.MAX_VALUE, 250, 80, 9, 5, 2, 1, 0), ubyteArray.sortedArrayDescending()) + val ubyteArray = ubyteArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UByte.MAX_VALUE, 250u) + assertArrayContentEquals(ubyteArrayOf(UByte.MAX_VALUE, 250u, 80u, 9u, 5u, 2u, 1u, 0u), ubyteArray.sortedArrayDescending()) - val ushortArray = ushortArrayOf(5, 2, 1, 9, 80, 0, UShort.MAX_VALUE, 65501) - assertArrayContentEquals(ushortArrayOf(UShort.MAX_VALUE, 65501, 80, 9, 5, 2, 1, 0), ushortArray.sortedArrayDescending()) + val ushortArray = ushortArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UShort.MAX_VALUE, 65501u) + assertArrayContentEquals(ushortArrayOf(UShort.MAX_VALUE, 65501u, 80u, 9u, 5u, 2u, 1u, 0u), ushortArray.sortedArrayDescending()) - val uintArray = uintArrayOf(5, 2, 1, 9, 80, 0, UInt.MAX_VALUE, 4294967200) - assertArrayContentEquals(uintArrayOf(UInt.MAX_VALUE, 4294967200, 80, 9, 5, 2, 1, 0), uintArray.sortedArrayDescending()) + val uintArray = uintArrayOf(5u, 2u, 1u, 9u, 80u, 0u, UInt.MAX_VALUE, 4294967200u) + assertArrayContentEquals(uintArrayOf(UInt.MAX_VALUE, 4294967200u, 80u, 9u, 5u, 2u, 1u, 0u), uintArray.sortedArrayDescending()) - val ulongArray = ulongArrayOf(5, 2, 1, 9, 80, 0, ULong.MAX_VALUE, ULong.MAX_VALUE - 123) - assertArrayContentEquals(ulongArrayOf(ULong.MAX_VALUE, ULong.MAX_VALUE - 123, 80, 9, 5, 2, 1, 0), ulongArray.sortedArrayDescending()) + val ulongArray = ulongArrayOf(5u, 2u, 1u, 9u, 80u, 0u, ULong.MAX_VALUE, ULong.MAX_VALUE - 123u) + assertArrayContentEquals(ulongArrayOf(ULong.MAX_VALUE, ULong.MAX_VALUE - 123u, 80u, 9u, 5u, 2u, 1u, 0u), ulongArray.sortedArrayDescending()) } @Test diff --git a/libraries/stdlib/test/text/StringNumberConversionTest.kt b/libraries/stdlib/test/text/StringNumberConversionTest.kt index 27b5aaa4fb1..314063d03ff 100644 --- a/libraries/stdlib/test/text/StringNumberConversionTest.kt +++ b/libraries/stdlib/test/text/StringNumberConversionTest.kt @@ -233,17 +233,16 @@ class StringNumberConversionTest { assertFailsOrNull(" ") } - @Suppress("SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED") compareConversionWithRadix(String::toUInt, String::toUIntOrNull) { assertProduces(10, "0", 0u) assertProduces(10, "473", 473u) assertProduces(10, "+42", 42u) assertProduces(10, "2147483647", 2147483647u) - assertProduces(16, "FF", 255) + assertProduces(16, "FF", 255u) assertProduces(16, "ffFFff01", 0u - 255u) - assertProduces(2, "1100110", 102) - assertProduces(27, "Kona", 411787) + assertProduces(2, "1100110", 102u) + assertProduces(27, "Kona", 411787u) assertFailsOrNull(10, "-0") assertFailsOrNull(10, "42949672940")