diff --git a/libraries/stdlib/test/collections/MapTest.kt b/libraries/stdlib/test/collections/MapTest.kt index 268294d0fa8..ef930f9ce35 100644 --- a/libraries/stdlib/test/collections/MapTest.kt +++ b/libraries/stdlib/test/collections/MapTest.kt @@ -7,6 +7,7 @@ package test.collections import kotlin.test.* import test.* +import kotlin.math.pow class MapTest { @@ -603,4 +604,166 @@ class MapTest { @Test fun plusAssignEmptySet() = testIdempotentAssign { it += setOf() } + private fun expectMinMaxWith(min: Pair, max: Pair, elements: Map, comparator: Comparator>) { + assertEquals(min, elements.minWithOrNull(comparator)?.toPair()) + assertEquals(max, elements.maxWithOrNull(comparator)?.toPair()) + assertEquals(min, elements.minWith(comparator).toPair()) + assertEquals(max, elements.maxWith(comparator).toPair()) + } + + @Test + fun minMaxWith() { + val map = listOf("a", "bcd", "Ef").associateWith { it.length } + expectMinMaxWith("Ef" to 2, "bcd" to 3, map, compareBy { it.key }) + expectMinMaxWith("a" to 1, "Ef" to 2, map, compareBy(String.CASE_INSENSITIVE_ORDER) { it.key }) + expectMinMaxWith("a" to 1, "bcd" to 3, map, compareBy { it.value }) + + } + + @Test + fun minMaxWithEmpty() { + val empty = mapOf() + val comparator = compareBy> { it.value } + assertNull(empty.minWithOrNull(comparator)) + assertNull(empty.maxWithOrNull(comparator)) + assertFailsWith { empty.minWith(comparator) } + assertFailsWith { empty.maxWith(comparator) } + } + + + private inline fun > expectMinMaxBy(min: Pair, max: Pair, elements: Map, selector: (Map.Entry) -> R) { + assertEquals(min, elements.minBy(selector).toPair()) + assertEquals(min, elements.minByOrNull(selector)?.toPair()) + assertEquals(max, elements.maxBy(selector).toPair()) + assertEquals(max, elements.maxByOrNull(selector)?.toPair()) + } + + @Test + fun minMaxBy() { + val map = listOf("a", "bcd", "Ef").associateWith { it.length } + expectMinMaxBy("Ef" to 2, "bcd" to 3, map, { it.key }) + expectMinMaxBy("a" to 1, "Ef" to 2, map, { it.key.lowercase() }) + expectMinMaxBy("a" to 1, "bcd" to 3, map, { it.value }) + } + + @Test + fun minMaxByEmpty() { + val empty = mapOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test fun minBySelectorEvaluateOnce() { + val source = listOf(1, 2, 3).associateWith { it } + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test fun maxBySelectorEvaluateOnce() { + val source = listOf(1, 2, 3).associateWith { it } + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + private inline fun > expectMinMaxOf(min: R, max: R, elements: Map, selector: (Map.Entry) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + val maps = (1..3).map { size -> listOf("a", "bcd", "Ef").take(size).associateWith { it.length } } + + expectMinMaxOf("a=1", "a=1", maps[0], { it.toString() }) + expectMinMaxOf("a=1", "bcd=3", maps[1], { it.toString() }) + expectMinMaxOf("Ef=2", "bcd=3", maps[2], { it.toString() }) + } + + @Test + fun minMaxOfDouble() { + val items = mapOf("a" to 0.0, "b" to 1.0, "c" to -1.0) + assertTrue(items.minOf { it.value.pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.value.pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.value.pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.value.pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.value * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.value * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.value * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.value * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val items = mapOf("a" to 0.0F, "b" to 1.0F, "c" to -1.0F) + assertTrue(items.minOf { it.value.pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.value.pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.value.pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.value.pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.value * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.value * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.value * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.value * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = mapOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: Map, comparator: Comparator, selector: (Map.Entry) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + val maps = (1..3).map { size -> listOf("a", "bcd", "Ef").take(size).associateWith { it.length } } + val comparator = String.CASE_INSENSITIVE_ORDER + expectMinMaxOfWith("a=1", "a=1", maps[0], comparator, { it.toString() }) + expectMinMaxOfWith("a=1", "bcd=3", maps[1], comparator, { it.toString() }) + expectMinMaxOfWith("a=1", "Ef=2", maps[2], comparator, { it.toString() }) + } + + @Test + fun minMaxOfWithEmpty() { + val empty = mapOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } } diff --git a/libraries/stdlib/test/generated/minmax/MinMaxArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxArrayTest.kt new file mode 100644 index 00000000000..f67a6c64e22 --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxArrayTest.kt @@ -0,0 +1,255 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxArrayTest { + + + private fun > expectMinMax(min: T, max: T, elements: Array) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax("a", "a", arrayOf("a")) + expectMinMax("a", "bcd", arrayOf("a", "bcd")) + expectMinMax("a", "e", arrayOf("a", "bcd", "e")) + expectMinMax(1, Int.MAX_VALUE, arrayOf(1, 2, Int.MAX_VALUE)) + expectMinMax(1, Long.MAX_VALUE, arrayOf(1, 2, Long.MAX_VALUE)) + expectMinMax(1U, UInt.MAX_VALUE, arrayOf(1U, 2U, UInt.MAX_VALUE)) + expectMinMax('a', Char.MAX_VALUE, arrayOf('a', 'b', Char.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = arrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + @Test + fun minMaxDouble() { + val zeroes = arrayOf(0.0, -0.0).apply { shuffle() } + val NaNs = arrayOf(0.0, Double.NaN).apply { shuffle() } + + assertIsNegativeZero(zeroes.min().toDouble()) + assertIsNegativeZero(zeroes.minOrNull()!!.toDouble()) + assertTrue(NaNs.min().isNaN()) + assertTrue(NaNs.minOrNull()!!.isNaN()) + + assertIsPositiveZero(zeroes.max().toDouble()) + assertIsPositiveZero(zeroes.maxOrNull()!!.toDouble()) + assertTrue(NaNs.max().isNaN()) + assertTrue(NaNs.maxOrNull()!!.isNaN()) + + } + + + @Test + fun minMaxFloat() { + val zeroes = arrayOf(0.0F, -0.0F).apply { shuffle() } + val NaNs = arrayOf(0.0F, Float.NaN).apply { shuffle() } + + assertIsNegativeZero(zeroes.min().toDouble()) + assertIsNegativeZero(zeroes.minOrNull()!!.toDouble()) + assertTrue(NaNs.min().isNaN()) + assertTrue(NaNs.minOrNull()!!.isNaN()) + + assertIsPositiveZero(zeroes.max().toDouble()) + assertIsPositiveZero(zeroes.maxOrNull()!!.toDouble()) + assertTrue(NaNs.max().isNaN()) + assertTrue(NaNs.maxOrNull()!!.isNaN()) + + } + + + + private fun expectMinMaxWith(min: T, max: T, elements: Array, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith("a", "a", arrayOf("a"), naturalOrder()) + expectMinMaxWith("a", "bcd", arrayOf("a", "bcd"), naturalOrder()) + expectMinMaxWith("a", "e", arrayOf("a", "bcd", "e"), naturalOrder()) + expectMinMaxWith("a", "B", arrayOf("a", "B"), String.CASE_INSENSITIVE_ORDER) + + } + + @Test + fun minMaxWithEmpty() { + val empty = arrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: T, max: T, elements: Array, selector: (T) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy("a", "a", arrayOf("a"), { it }) + expectMinMaxBy("a", "bcd", arrayOf("a", "bcd"), { it }) + expectMinMaxBy("a", "e", arrayOf("a", "bcd", "e"), { it }) + expectMinMaxBy("De", "abc", arrayOf("abc", "De"), { it.length }) + + } + + @Test + fun minMaxByEmpty() { + val empty = arrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = arrayOf("a", "bcd", "e") + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = arrayOf("a", "bcd", "e") + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: Array, selector: (T) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf("_" + "a", "_" + "a", arrayOf("a"), { "_$it" }) + expectMinMaxOf("_" + "a", "_" + "bcd", arrayOf("a", "bcd"), { "_$it" }) + expectMinMaxOf("_" + "a", "_" + "e", arrayOf("a", "bcd", "e"), { "_$it" }) + + } + + @Test + fun minMaxOfDouble() { + val middle = "bcd" + val items = arrayOf("a", "bcd", "e").apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = "bcd" + val items = arrayOf("a", "bcd", "e").apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = arrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: Array, comparator: Comparator, selector: (T) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith("_" + "a", "_" + "a", arrayOf("a"), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + "bcd", "_" + "a", arrayOf("a", "bcd"), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + "e", "_" + "a", arrayOf("a", "bcd", "e"), reverseOrder(), { "_$it" }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = arrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxByteArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxByteArrayTest.kt new file mode 100644 index 00000000000..16792dd75f7 --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxByteArrayTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxByteArrayTest { + + + private fun expectMinMax(min: Byte, max: Byte, elements: ByteArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1, 1, byteArrayOf(1)) + expectMinMax(1, 2, byteArrayOf(1, 2)) + expectMinMax(1, Byte.MAX_VALUE, byteArrayOf(1, 2, Byte.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = byteArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: Byte, max: Byte, elements: ByteArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1, 1, byteArrayOf(1), naturalOrder()) + expectMinMaxWith(1, 2, byteArrayOf(1, 2), naturalOrder()) + expectMinMaxWith(1, Byte.MAX_VALUE, byteArrayOf(1, 2, Byte.MAX_VALUE), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = byteArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: Byte, max: Byte, elements: ByteArray, selector: (Byte) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1, 1, byteArrayOf(1), { it }) + expectMinMaxBy(1, 2, byteArrayOf(1, 2), { it }) + expectMinMaxBy(1, Byte.MAX_VALUE, byteArrayOf(1, 2, Byte.MAX_VALUE), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = byteArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = byteArrayOf(1, 2, Byte.MAX_VALUE) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = byteArrayOf(1, 2, Byte.MAX_VALUE) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: ByteArray, selector: (Byte) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf(-1, -1, byteArrayOf(1), { -it }) + expectMinMaxOf(-2, -1, byteArrayOf(1, 2), { -it }) + expectMinMaxOf(-Byte.MAX_VALUE, -1, byteArrayOf(1, 2, Byte.MAX_VALUE), { -it }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2 + val items = byteArrayOf(1, 2, Byte.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2 + val items = byteArrayOf(1, 2, Byte.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = byteArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: ByteArray, comparator: Comparator, selector: (Byte) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith(-1, -1, byteArrayOf(1), reverseOrder(), { -it }) + expectMinMaxOfWith(-1, -2, byteArrayOf(1, 2), reverseOrder(), { -it }) + expectMinMaxOfWith(-1, -Byte.MAX_VALUE, byteArrayOf(1, 2, Byte.MAX_VALUE), reverseOrder(), { -it }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = byteArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxCharArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxCharArrayTest.kt new file mode 100644 index 00000000000..3e620af7cd6 --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxCharArrayTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxCharArrayTest { + + + private fun expectMinMax(min: Char, max: Char, elements: CharArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax('a', 'a', charArrayOf('a')) + expectMinMax('a', 'b', charArrayOf('a', 'b')) + expectMinMax('a', Char.MAX_VALUE, charArrayOf('a', 'b', Char.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = charArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: Char, max: Char, elements: CharArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith('a', 'a', charArrayOf('a'), naturalOrder()) + expectMinMaxWith('a', 'b', charArrayOf('a', 'b'), naturalOrder()) + expectMinMaxWith('a', Char.MAX_VALUE, charArrayOf('a', 'b', Char.MAX_VALUE), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = charArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: Char, max: Char, elements: CharArray, selector: (Char) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy('a', 'a', charArrayOf('a'), { it }) + expectMinMaxBy('a', 'b', charArrayOf('a', 'b'), { it }) + expectMinMaxBy('a', Char.MAX_VALUE, charArrayOf('a', 'b', Char.MAX_VALUE), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = charArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = charArrayOf('a', 'b', Char.MAX_VALUE) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = charArrayOf('a', 'b', Char.MAX_VALUE) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: CharArray, selector: (Char) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf("_" + 'a', "_" + 'a', charArrayOf('a'), { "_$it" }) + expectMinMaxOf("_" + 'a', "_" + 'b', charArrayOf('a', 'b'), { "_$it" }) + expectMinMaxOf("_" + 'a', "_" + Char.MAX_VALUE, charArrayOf('a', 'b', Char.MAX_VALUE), { "_$it" }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 'b' + val items = charArrayOf('a', 'b', Char.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 'b' + val items = charArrayOf('a', 'b', Char.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = charArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: CharArray, comparator: Comparator, selector: (Char) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith("_" + 'a', "_" + 'a', charArrayOf('a'), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + 'b', "_" + 'a', charArrayOf('a', 'b'), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + Char.MAX_VALUE, "_" + 'a', charArrayOf('a', 'b', Char.MAX_VALUE), reverseOrder(), { "_$it" }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = charArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxCharSequenceTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxCharSequenceTest.kt new file mode 100644 index 00000000000..90a596c9bc3 --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxCharSequenceTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxCharSequenceTest { + + + private fun expectMinMax(min: Char, max: Char, elements: CharSequence) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax('a', 'a', StringBuilder(charArrayOf('a').concatToString())) + expectMinMax('a', 'b', StringBuilder(charArrayOf('a', 'b').concatToString())) + expectMinMax('a', Char.MAX_VALUE, StringBuilder(charArrayOf('a', 'b', Char.MAX_VALUE).concatToString())) + + } + + @Test + fun minMaxEmpty() { + val empty = StringBuilder() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: Char, max: Char, elements: CharSequence, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith('a', 'a', StringBuilder(charArrayOf('a').concatToString()), naturalOrder()) + expectMinMaxWith('a', 'b', StringBuilder(charArrayOf('a', 'b').concatToString()), naturalOrder()) + expectMinMaxWith('a', Char.MAX_VALUE, StringBuilder(charArrayOf('a', 'b', Char.MAX_VALUE).concatToString()), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = StringBuilder() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: Char, max: Char, elements: CharSequence, selector: (Char) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy('a', 'a', StringBuilder(charArrayOf('a').concatToString()), { it }) + expectMinMaxBy('a', 'b', StringBuilder(charArrayOf('a', 'b').concatToString()), { it }) + expectMinMaxBy('a', Char.MAX_VALUE, StringBuilder(charArrayOf('a', 'b', Char.MAX_VALUE).concatToString()), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = StringBuilder() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = StringBuilder(charArrayOf('a', 'b', Char.MAX_VALUE).concatToString()) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = StringBuilder(charArrayOf('a', 'b', Char.MAX_VALUE).concatToString()) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: CharSequence, selector: (Char) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf("_" + 'a', "_" + 'a', StringBuilder(charArrayOf('a').concatToString()), { "_$it" }) + expectMinMaxOf("_" + 'a', "_" + 'b', StringBuilder(charArrayOf('a', 'b').concatToString()), { "_$it" }) + expectMinMaxOf("_" + 'a', "_" + Char.MAX_VALUE, StringBuilder(charArrayOf('a', 'b', Char.MAX_VALUE).concatToString()), { "_$it" }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 'b' + val items = StringBuilder(charArrayOf('a', 'b', Char.MAX_VALUE).apply { shuffle() }.concatToString()) + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 'b' + val items = StringBuilder(charArrayOf('a', 'b', Char.MAX_VALUE).apply { shuffle() }.concatToString()) + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = StringBuilder() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: CharSequence, comparator: Comparator, selector: (Char) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith("_" + 'a', "_" + 'a', StringBuilder(charArrayOf('a').concatToString()), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + 'b', "_" + 'a', StringBuilder(charArrayOf('a', 'b').concatToString()), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + Char.MAX_VALUE, "_" + 'a', StringBuilder(charArrayOf('a', 'b', Char.MAX_VALUE).concatToString()), reverseOrder(), { "_$it" }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = StringBuilder() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxDoubleArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxDoubleArrayTest.kt new file mode 100644 index 00000000000..079fdb47a7a --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxDoubleArrayTest.kt @@ -0,0 +1,231 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxDoubleArrayTest { + + + private fun expectMinMax(min: Double, max: Double, elements: DoubleArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1.0, 1.0, doubleArrayOf(1.0)) + expectMinMax(1.0, 2.0, doubleArrayOf(1.0, 2.0)) + expectMinMax(1.0, Double.POSITIVE_INFINITY, doubleArrayOf(1.0, 2.0, Double.POSITIVE_INFINITY)) + + } + + @Test + fun minMaxEmpty() { + val empty = doubleArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + @Test + fun minMaxDouble() { + val zeroes = doubleArrayOf(0.0, -0.0).apply { shuffle() } + val NaNs = doubleArrayOf(0.0, Double.NaN).apply { shuffle() } + + assertIsNegativeZero(zeroes.min().toDouble()) + assertIsNegativeZero(zeroes.minOrNull()!!.toDouble()) + assertTrue(NaNs.min().isNaN()) + assertTrue(NaNs.minOrNull()!!.isNaN()) + + assertIsPositiveZero(zeroes.max().toDouble()) + assertIsPositiveZero(zeroes.maxOrNull()!!.toDouble()) + assertTrue(NaNs.max().isNaN()) + assertTrue(NaNs.maxOrNull()!!.isNaN()) + + } + + + + private fun expectMinMaxWith(min: Double, max: Double, elements: DoubleArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1.0, 1.0, doubleArrayOf(1.0), naturalOrder()) + expectMinMaxWith(1.0, 2.0, doubleArrayOf(1.0, 2.0), naturalOrder()) + expectMinMaxWith(1.0, Double.POSITIVE_INFINITY, doubleArrayOf(1.0, 2.0, Double.POSITIVE_INFINITY), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = doubleArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: Double, max: Double, elements: DoubleArray, selector: (Double) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1.0, 1.0, doubleArrayOf(1.0), { it }) + expectMinMaxBy(1.0, 2.0, doubleArrayOf(1.0, 2.0), { it }) + expectMinMaxBy(1.0, Double.POSITIVE_INFINITY, doubleArrayOf(1.0, 2.0, Double.POSITIVE_INFINITY), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = doubleArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = doubleArrayOf(1.0, 2.0, Double.POSITIVE_INFINITY) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = doubleArrayOf(1.0, 2.0, Double.POSITIVE_INFINITY) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: DoubleArray, selector: (Double) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf(-1.0, -1.0, doubleArrayOf(1.0), { -it }) + expectMinMaxOf(-2.0, -1.0, doubleArrayOf(1.0, 2.0), { -it }) + expectMinMaxOf(-Double.POSITIVE_INFINITY, -1.0, doubleArrayOf(1.0, 2.0, Double.POSITIVE_INFINITY), { -it }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2.0 + val items = doubleArrayOf(1.0, 2.0, Double.POSITIVE_INFINITY).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2.0 + val items = doubleArrayOf(1.0, 2.0, Double.POSITIVE_INFINITY).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = doubleArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: DoubleArray, comparator: Comparator, selector: (Double) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith(-1.0, -1.0, doubleArrayOf(1.0), reverseOrder(), { -it }) + expectMinMaxOfWith(-1.0, -2.0, doubleArrayOf(1.0, 2.0), reverseOrder(), { -it }) + expectMinMaxOfWith(-1.0, -Double.POSITIVE_INFINITY, doubleArrayOf(1.0, 2.0, Double.POSITIVE_INFINITY), reverseOrder(), { -it }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = doubleArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxFloatArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxFloatArrayTest.kt new file mode 100644 index 00000000000..c73a4af512d --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxFloatArrayTest.kt @@ -0,0 +1,231 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxFloatArrayTest { + + + private fun expectMinMax(min: Float, max: Float, elements: FloatArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1.0F, 1.0F, floatArrayOf(1.0F)) + expectMinMax(1.0F, 2.0F, floatArrayOf(1.0F, 2.0F)) + expectMinMax(1.0F, Float.POSITIVE_INFINITY, floatArrayOf(1.0F, 2.0F, Float.POSITIVE_INFINITY)) + + } + + @Test + fun minMaxEmpty() { + val empty = floatArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + @Test + fun minMaxFloat() { + val zeroes = floatArrayOf(0.0F, -0.0F).apply { shuffle() } + val NaNs = floatArrayOf(0.0F, Float.NaN).apply { shuffle() } + + assertIsNegativeZero(zeroes.min().toDouble()) + assertIsNegativeZero(zeroes.minOrNull()!!.toDouble()) + assertTrue(NaNs.min().isNaN()) + assertTrue(NaNs.minOrNull()!!.isNaN()) + + assertIsPositiveZero(zeroes.max().toDouble()) + assertIsPositiveZero(zeroes.maxOrNull()!!.toDouble()) + assertTrue(NaNs.max().isNaN()) + assertTrue(NaNs.maxOrNull()!!.isNaN()) + + } + + + + private fun expectMinMaxWith(min: Float, max: Float, elements: FloatArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1.0F, 1.0F, floatArrayOf(1.0F), naturalOrder()) + expectMinMaxWith(1.0F, 2.0F, floatArrayOf(1.0F, 2.0F), naturalOrder()) + expectMinMaxWith(1.0F, Float.POSITIVE_INFINITY, floatArrayOf(1.0F, 2.0F, Float.POSITIVE_INFINITY), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = floatArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: Float, max: Float, elements: FloatArray, selector: (Float) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1.0F, 1.0F, floatArrayOf(1.0F), { it }) + expectMinMaxBy(1.0F, 2.0F, floatArrayOf(1.0F, 2.0F), { it }) + expectMinMaxBy(1.0F, Float.POSITIVE_INFINITY, floatArrayOf(1.0F, 2.0F, Float.POSITIVE_INFINITY), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = floatArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = floatArrayOf(1.0F, 2.0F, Float.POSITIVE_INFINITY) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = floatArrayOf(1.0F, 2.0F, Float.POSITIVE_INFINITY) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: FloatArray, selector: (Float) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf(-1.0F, -1.0F, floatArrayOf(1.0F), { -it }) + expectMinMaxOf(-2.0F, -1.0F, floatArrayOf(1.0F, 2.0F), { -it }) + expectMinMaxOf(-Float.POSITIVE_INFINITY, -1.0F, floatArrayOf(1.0F, 2.0F, Float.POSITIVE_INFINITY), { -it }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2.0F + val items = floatArrayOf(1.0F, 2.0F, Float.POSITIVE_INFINITY).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2.0F + val items = floatArrayOf(1.0F, 2.0F, Float.POSITIVE_INFINITY).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = floatArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: FloatArray, comparator: Comparator, selector: (Float) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith(-1.0F, -1.0F, floatArrayOf(1.0F), reverseOrder(), { -it }) + expectMinMaxOfWith(-1.0F, -2.0F, floatArrayOf(1.0F, 2.0F), reverseOrder(), { -it }) + expectMinMaxOfWith(-1.0F, -Float.POSITIVE_INFINITY, floatArrayOf(1.0F, 2.0F, Float.POSITIVE_INFINITY), reverseOrder(), { -it }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = floatArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxIntArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxIntArrayTest.kt new file mode 100644 index 00000000000..dc3985e0d52 --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxIntArrayTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxIntArrayTest { + + + private fun expectMinMax(min: Int, max: Int, elements: IntArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1, 1, intArrayOf(1)) + expectMinMax(1, 2, intArrayOf(1, 2)) + expectMinMax(1, Int.MAX_VALUE, intArrayOf(1, 2, Int.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = intArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: Int, max: Int, elements: IntArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1, 1, intArrayOf(1), naturalOrder()) + expectMinMaxWith(1, 2, intArrayOf(1, 2), naturalOrder()) + expectMinMaxWith(1, Int.MAX_VALUE, intArrayOf(1, 2, Int.MAX_VALUE), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = intArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: Int, max: Int, elements: IntArray, selector: (Int) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1, 1, intArrayOf(1), { it }) + expectMinMaxBy(1, 2, intArrayOf(1, 2), { it }) + expectMinMaxBy(1, Int.MAX_VALUE, intArrayOf(1, 2, Int.MAX_VALUE), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = intArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = intArrayOf(1, 2, Int.MAX_VALUE) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = intArrayOf(1, 2, Int.MAX_VALUE) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: IntArray, selector: (Int) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf(-1, -1, intArrayOf(1), { -it }) + expectMinMaxOf(-2, -1, intArrayOf(1, 2), { -it }) + expectMinMaxOf(-Int.MAX_VALUE, -1, intArrayOf(1, 2, Int.MAX_VALUE), { -it }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2 + val items = intArrayOf(1, 2, Int.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2 + val items = intArrayOf(1, 2, Int.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = intArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: IntArray, comparator: Comparator, selector: (Int) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith(-1, -1, intArrayOf(1), reverseOrder(), { -it }) + expectMinMaxOfWith(-1, -2, intArrayOf(1, 2), reverseOrder(), { -it }) + expectMinMaxOfWith(-1, -Int.MAX_VALUE, intArrayOf(1, 2, Int.MAX_VALUE), reverseOrder(), { -it }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = intArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxIterableTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxIterableTest.kt new file mode 100644 index 00000000000..69db14a3f48 --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxIterableTest.kt @@ -0,0 +1,255 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxIterableTest { + + + private fun > expectMinMax(min: T, max: T, elements: Iterable) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax("a", "a", listOf("a")) + expectMinMax("a", "bcd", listOf("a", "bcd")) + expectMinMax("a", "e", listOf("a", "bcd", "e")) + expectMinMax(1, Int.MAX_VALUE, listOf(1, 2, Int.MAX_VALUE)) + expectMinMax(1, Long.MAX_VALUE, listOf(1, 2, Long.MAX_VALUE)) + expectMinMax(1U, UInt.MAX_VALUE, listOf(1U, 2U, UInt.MAX_VALUE)) + expectMinMax('a', Char.MAX_VALUE, listOf('a', 'b', Char.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = listOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + @Test + fun minMaxDouble() { + val zeroes = listOf(0.0, -0.0).shuffled() + val NaNs = listOf(0.0, Double.NaN).shuffled() + + assertIsNegativeZero(zeroes.min().toDouble()) + assertIsNegativeZero(zeroes.minOrNull()!!.toDouble()) + assertTrue(NaNs.min().isNaN()) + assertTrue(NaNs.minOrNull()!!.isNaN()) + + assertIsPositiveZero(zeroes.max().toDouble()) + assertIsPositiveZero(zeroes.maxOrNull()!!.toDouble()) + assertTrue(NaNs.max().isNaN()) + assertTrue(NaNs.maxOrNull()!!.isNaN()) + + } + + + @Test + fun minMaxFloat() { + val zeroes = listOf(0.0F, -0.0F).shuffled() + val NaNs = listOf(0.0F, Float.NaN).shuffled() + + assertIsNegativeZero(zeroes.min().toDouble()) + assertIsNegativeZero(zeroes.minOrNull()!!.toDouble()) + assertTrue(NaNs.min().isNaN()) + assertTrue(NaNs.minOrNull()!!.isNaN()) + + assertIsPositiveZero(zeroes.max().toDouble()) + assertIsPositiveZero(zeroes.maxOrNull()!!.toDouble()) + assertTrue(NaNs.max().isNaN()) + assertTrue(NaNs.maxOrNull()!!.isNaN()) + + } + + + + private fun expectMinMaxWith(min: T, max: T, elements: Iterable, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith("a", "a", listOf("a"), naturalOrder()) + expectMinMaxWith("a", "bcd", listOf("a", "bcd"), naturalOrder()) + expectMinMaxWith("a", "e", listOf("a", "bcd", "e"), naturalOrder()) + expectMinMaxWith("a", "B", listOf("a", "B"), String.CASE_INSENSITIVE_ORDER) + + } + + @Test + fun minMaxWithEmpty() { + val empty = listOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: T, max: T, elements: Iterable, selector: (T) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy("a", "a", listOf("a"), { it }) + expectMinMaxBy("a", "bcd", listOf("a", "bcd"), { it }) + expectMinMaxBy("a", "e", listOf("a", "bcd", "e"), { it }) + expectMinMaxBy("De", "abc", listOf("abc", "De"), { it.length }) + + } + + @Test + fun minMaxByEmpty() { + val empty = listOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = listOf("a", "bcd", "e") + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = listOf("a", "bcd", "e") + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: Iterable, selector: (T) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf("_" + "a", "_" + "a", listOf("a"), { "_$it" }) + expectMinMaxOf("_" + "a", "_" + "bcd", listOf("a", "bcd"), { "_$it" }) + expectMinMaxOf("_" + "a", "_" + "e", listOf("a", "bcd", "e"), { "_$it" }) + + } + + @Test + fun minMaxOfDouble() { + val middle = "bcd" + val items = listOf("a", "bcd", "e").shuffled() + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = "bcd" + val items = listOf("a", "bcd", "e").shuffled() + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = listOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: Iterable, comparator: Comparator, selector: (T) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith("_" + "a", "_" + "a", listOf("a"), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + "bcd", "_" + "a", listOf("a", "bcd"), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + "e", "_" + "a", listOf("a", "bcd", "e"), reverseOrder(), { "_$it" }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = listOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxLongArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxLongArrayTest.kt new file mode 100644 index 00000000000..709c0ca9cbd --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxLongArrayTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxLongArrayTest { + + + private fun expectMinMax(min: Long, max: Long, elements: LongArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1, 1, longArrayOf(1)) + expectMinMax(1, 2, longArrayOf(1, 2)) + expectMinMax(1, Long.MAX_VALUE, longArrayOf(1, 2, Long.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = longArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: Long, max: Long, elements: LongArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1, 1, longArrayOf(1), naturalOrder()) + expectMinMaxWith(1, 2, longArrayOf(1, 2), naturalOrder()) + expectMinMaxWith(1, Long.MAX_VALUE, longArrayOf(1, 2, Long.MAX_VALUE), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = longArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: Long, max: Long, elements: LongArray, selector: (Long) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1, 1, longArrayOf(1), { it }) + expectMinMaxBy(1, 2, longArrayOf(1, 2), { it }) + expectMinMaxBy(1, Long.MAX_VALUE, longArrayOf(1, 2, Long.MAX_VALUE), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = longArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = longArrayOf(1, 2, Long.MAX_VALUE) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = longArrayOf(1, 2, Long.MAX_VALUE) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: LongArray, selector: (Long) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf(-1, -1, longArrayOf(1), { -it }) + expectMinMaxOf(-2, -1, longArrayOf(1, 2), { -it }) + expectMinMaxOf(-Long.MAX_VALUE, -1, longArrayOf(1, 2, Long.MAX_VALUE), { -it }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2 + val items = longArrayOf(1, 2, Long.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2 + val items = longArrayOf(1, 2, Long.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = longArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: LongArray, comparator: Comparator, selector: (Long) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith(-1, -1, longArrayOf(1), reverseOrder(), { -it }) + expectMinMaxOfWith(-1, -2, longArrayOf(1, 2), reverseOrder(), { -it }) + expectMinMaxOfWith(-1, -Long.MAX_VALUE, longArrayOf(1, 2, Long.MAX_VALUE), reverseOrder(), { -it }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = longArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxSequenceTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxSequenceTest.kt new file mode 100644 index 00000000000..f4868a8c22e --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxSequenceTest.kt @@ -0,0 +1,255 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxSequenceTest { + + + private fun > expectMinMax(min: T, max: T, elements: Sequence) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax("a", "a", sequenceOf("a")) + expectMinMax("a", "bcd", sequenceOf("a", "bcd")) + expectMinMax("a", "e", sequenceOf("a", "bcd", "e")) + expectMinMax(1, Int.MAX_VALUE, sequenceOf(1, 2, Int.MAX_VALUE)) + expectMinMax(1, Long.MAX_VALUE, sequenceOf(1, 2, Long.MAX_VALUE)) + expectMinMax(1U, UInt.MAX_VALUE, sequenceOf(1U, 2U, UInt.MAX_VALUE)) + expectMinMax('a', Char.MAX_VALUE, sequenceOf('a', 'b', Char.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = sequenceOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + @Test + fun minMaxDouble() { + val zeroes = sequenceOf(0.0, -0.0).shuffled() + val NaNs = sequenceOf(0.0, Double.NaN).shuffled() + + assertIsNegativeZero(zeroes.min().toDouble()) + assertIsNegativeZero(zeroes.minOrNull()!!.toDouble()) + assertTrue(NaNs.min().isNaN()) + assertTrue(NaNs.minOrNull()!!.isNaN()) + + assertIsPositiveZero(zeroes.max().toDouble()) + assertIsPositiveZero(zeroes.maxOrNull()!!.toDouble()) + assertTrue(NaNs.max().isNaN()) + assertTrue(NaNs.maxOrNull()!!.isNaN()) + + } + + + @Test + fun minMaxFloat() { + val zeroes = sequenceOf(0.0F, -0.0F).shuffled() + val NaNs = sequenceOf(0.0F, Float.NaN).shuffled() + + assertIsNegativeZero(zeroes.min().toDouble()) + assertIsNegativeZero(zeroes.minOrNull()!!.toDouble()) + assertTrue(NaNs.min().isNaN()) + assertTrue(NaNs.minOrNull()!!.isNaN()) + + assertIsPositiveZero(zeroes.max().toDouble()) + assertIsPositiveZero(zeroes.maxOrNull()!!.toDouble()) + assertTrue(NaNs.max().isNaN()) + assertTrue(NaNs.maxOrNull()!!.isNaN()) + + } + + + + private fun expectMinMaxWith(min: T, max: T, elements: Sequence, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith("a", "a", sequenceOf("a"), naturalOrder()) + expectMinMaxWith("a", "bcd", sequenceOf("a", "bcd"), naturalOrder()) + expectMinMaxWith("a", "e", sequenceOf("a", "bcd", "e"), naturalOrder()) + expectMinMaxWith("a", "B", sequenceOf("a", "B"), String.CASE_INSENSITIVE_ORDER) + + } + + @Test + fun minMaxWithEmpty() { + val empty = sequenceOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: T, max: T, elements: Sequence, selector: (T) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy("a", "a", sequenceOf("a"), { it }) + expectMinMaxBy("a", "bcd", sequenceOf("a", "bcd"), { it }) + expectMinMaxBy("a", "e", sequenceOf("a", "bcd", "e"), { it }) + expectMinMaxBy("De", "abc", sequenceOf("abc", "De"), { it.length }) + + } + + @Test + fun minMaxByEmpty() { + val empty = sequenceOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = sequenceOf("a", "bcd", "e") + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = sequenceOf("a", "bcd", "e") + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: Sequence, selector: (T) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf("_" + "a", "_" + "a", sequenceOf("a"), { "_$it" }) + expectMinMaxOf("_" + "a", "_" + "bcd", sequenceOf("a", "bcd"), { "_$it" }) + expectMinMaxOf("_" + "a", "_" + "e", sequenceOf("a", "bcd", "e"), { "_$it" }) + + } + + @Test + fun minMaxOfDouble() { + val middle = "bcd" + val items = sequenceOf("a", "bcd", "e").shuffled() + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = "bcd" + val items = sequenceOf("a", "bcd", "e").shuffled() + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = sequenceOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: Sequence, comparator: Comparator, selector: (T) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith("_" + "a", "_" + "a", sequenceOf("a"), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + "bcd", "_" + "a", sequenceOf("a", "bcd"), reverseOrder(), { "_$it" }) + expectMinMaxOfWith("_" + "e", "_" + "a", sequenceOf("a", "bcd", "e"), reverseOrder(), { "_$it" }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = sequenceOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxShortArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxShortArrayTest.kt new file mode 100644 index 00000000000..f9f33f04925 --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxShortArrayTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxShortArrayTest { + + + private fun expectMinMax(min: Short, max: Short, elements: ShortArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1, 1, shortArrayOf(1)) + expectMinMax(1, 2, shortArrayOf(1, 2)) + expectMinMax(1, Short.MAX_VALUE, shortArrayOf(1, 2, Short.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = shortArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: Short, max: Short, elements: ShortArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1, 1, shortArrayOf(1), naturalOrder()) + expectMinMaxWith(1, 2, shortArrayOf(1, 2), naturalOrder()) + expectMinMaxWith(1, Short.MAX_VALUE, shortArrayOf(1, 2, Short.MAX_VALUE), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = shortArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: Short, max: Short, elements: ShortArray, selector: (Short) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1, 1, shortArrayOf(1), { it }) + expectMinMaxBy(1, 2, shortArrayOf(1, 2), { it }) + expectMinMaxBy(1, Short.MAX_VALUE, shortArrayOf(1, 2, Short.MAX_VALUE), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = shortArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = shortArrayOf(1, 2, Short.MAX_VALUE) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = shortArrayOf(1, 2, Short.MAX_VALUE) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: ShortArray, selector: (Short) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf(-1, -1, shortArrayOf(1), { -it }) + expectMinMaxOf(-2, -1, shortArrayOf(1, 2), { -it }) + expectMinMaxOf(-Short.MAX_VALUE, -1, shortArrayOf(1, 2, Short.MAX_VALUE), { -it }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2 + val items = shortArrayOf(1, 2, Short.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2 + val items = shortArrayOf(1, 2, Short.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = shortArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: ShortArray, comparator: Comparator, selector: (Short) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith(-1, -1, shortArrayOf(1), reverseOrder(), { -it }) + expectMinMaxOfWith(-1, -2, shortArrayOf(1, 2), reverseOrder(), { -it }) + expectMinMaxOfWith(-1, -Short.MAX_VALUE, shortArrayOf(1, 2, Short.MAX_VALUE), reverseOrder(), { -it }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = shortArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxUByteArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxUByteArrayTest.kt new file mode 100644 index 00000000000..26d4468fcfd --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxUByteArrayTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxUByteArrayTest { + + + private fun expectMinMax(min: UByte, max: UByte, elements: UByteArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1U, 1U, ubyteArrayOf(1U)) + expectMinMax(1U, 2U, ubyteArrayOf(1U, 2U)) + expectMinMax(1U, UByte.MAX_VALUE, ubyteArrayOf(1U, 2U, UByte.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = ubyteArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: UByte, max: UByte, elements: UByteArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1U, 1U, ubyteArrayOf(1U), naturalOrder()) + expectMinMaxWith(1U, 2U, ubyteArrayOf(1U, 2U), naturalOrder()) + expectMinMaxWith(1U, UByte.MAX_VALUE, ubyteArrayOf(1U, 2U, UByte.MAX_VALUE), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = ubyteArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: UByte, max: UByte, elements: UByteArray, selector: (UByte) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1U, 1U, ubyteArrayOf(1U), { it }) + expectMinMaxBy(1U, 2U, ubyteArrayOf(1U, 2U), { it }) + expectMinMaxBy(1U, UByte.MAX_VALUE, ubyteArrayOf(1U, 2U, UByte.MAX_VALUE), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = ubyteArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = ubyteArrayOf(1U, 2U, UByte.MAX_VALUE) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = ubyteArrayOf(1U, 2U, UByte.MAX_VALUE) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: UByteArray, selector: (UByte) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf((0u - 1U).toUByte(), (0u - 1U).toUByte(), ubyteArrayOf(1U), { (0u - it).toUByte() }) + expectMinMaxOf((0u - 2U).toUByte(), (0u - 1U).toUByte(), ubyteArrayOf(1U, 2U), { (0u - it).toUByte() }) + expectMinMaxOf((0u - UByte.MAX_VALUE).toUByte(), (0u - 1U).toUByte(), ubyteArrayOf(1U, 2U, UByte.MAX_VALUE), { (0u - it).toUByte() }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2U + val items = ubyteArrayOf(1U, 2U, UByte.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2U + val items = ubyteArrayOf(1U, 2U, UByte.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = ubyteArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: UByteArray, comparator: Comparator, selector: (UByte) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith((0u - 1U).toUByte(), (0u - 1U).toUByte(), ubyteArrayOf(1U), reverseOrder(), { (0u - it).toUByte() }) + expectMinMaxOfWith((0u - 1U).toUByte(), (0u - 2U).toUByte(), ubyteArrayOf(1U, 2U), reverseOrder(), { (0u - it).toUByte() }) + expectMinMaxOfWith((0u - 1U).toUByte(), (0u - UByte.MAX_VALUE).toUByte(), ubyteArrayOf(1U, 2U, UByte.MAX_VALUE), reverseOrder(), { (0u - it).toUByte() }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = ubyteArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxUIntArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxUIntArrayTest.kt new file mode 100644 index 00000000000..97dfe62bcce --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxUIntArrayTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxUIntArrayTest { + + + private fun expectMinMax(min: UInt, max: UInt, elements: UIntArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1U, 1U, uintArrayOf(1U)) + expectMinMax(1U, 2U, uintArrayOf(1U, 2U)) + expectMinMax(1U, UInt.MAX_VALUE, uintArrayOf(1U, 2U, UInt.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = uintArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: UInt, max: UInt, elements: UIntArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1U, 1U, uintArrayOf(1U), naturalOrder()) + expectMinMaxWith(1U, 2U, uintArrayOf(1U, 2U), naturalOrder()) + expectMinMaxWith(1U, UInt.MAX_VALUE, uintArrayOf(1U, 2U, UInt.MAX_VALUE), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = uintArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: UInt, max: UInt, elements: UIntArray, selector: (UInt) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1U, 1U, uintArrayOf(1U), { it }) + expectMinMaxBy(1U, 2U, uintArrayOf(1U, 2U), { it }) + expectMinMaxBy(1U, UInt.MAX_VALUE, uintArrayOf(1U, 2U, UInt.MAX_VALUE), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = uintArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = uintArrayOf(1U, 2U, UInt.MAX_VALUE) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = uintArrayOf(1U, 2U, UInt.MAX_VALUE) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: UIntArray, selector: (UInt) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf((0u - 1U).toUInt(), (0u - 1U).toUInt(), uintArrayOf(1U), { (0u - it).toUInt() }) + expectMinMaxOf((0u - 2U).toUInt(), (0u - 1U).toUInt(), uintArrayOf(1U, 2U), { (0u - it).toUInt() }) + expectMinMaxOf((0u - UInt.MAX_VALUE).toUInt(), (0u - 1U).toUInt(), uintArrayOf(1U, 2U, UInt.MAX_VALUE), { (0u - it).toUInt() }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2U + val items = uintArrayOf(1U, 2U, UInt.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2U + val items = uintArrayOf(1U, 2U, UInt.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = uintArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: UIntArray, comparator: Comparator, selector: (UInt) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith((0u - 1U).toUInt(), (0u - 1U).toUInt(), uintArrayOf(1U), reverseOrder(), { (0u - it).toUInt() }) + expectMinMaxOfWith((0u - 1U).toUInt(), (0u - 2U).toUInt(), uintArrayOf(1U, 2U), reverseOrder(), { (0u - it).toUInt() }) + expectMinMaxOfWith((0u - 1U).toUInt(), (0u - UInt.MAX_VALUE).toUInt(), uintArrayOf(1U, 2U, UInt.MAX_VALUE), reverseOrder(), { (0u - it).toUInt() }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = uintArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxULongArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxULongArrayTest.kt new file mode 100644 index 00000000000..3f793492ec9 --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxULongArrayTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxULongArrayTest { + + + private fun expectMinMax(min: ULong, max: ULong, elements: ULongArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1UL, 1UL, ulongArrayOf(1UL)) + expectMinMax(1UL, 2UL, ulongArrayOf(1UL, 2UL)) + expectMinMax(1UL, ULong.MAX_VALUE, ulongArrayOf(1UL, 2UL, ULong.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = ulongArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: ULong, max: ULong, elements: ULongArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1UL, 1UL, ulongArrayOf(1UL), naturalOrder()) + expectMinMaxWith(1UL, 2UL, ulongArrayOf(1UL, 2UL), naturalOrder()) + expectMinMaxWith(1UL, ULong.MAX_VALUE, ulongArrayOf(1UL, 2UL, ULong.MAX_VALUE), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = ulongArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: ULong, max: ULong, elements: ULongArray, selector: (ULong) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1UL, 1UL, ulongArrayOf(1UL), { it }) + expectMinMaxBy(1UL, 2UL, ulongArrayOf(1UL, 2UL), { it }) + expectMinMaxBy(1UL, ULong.MAX_VALUE, ulongArrayOf(1UL, 2UL, ULong.MAX_VALUE), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = ulongArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = ulongArrayOf(1UL, 2UL, ULong.MAX_VALUE) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = ulongArrayOf(1UL, 2UL, ULong.MAX_VALUE) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: ULongArray, selector: (ULong) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf((0u - 1UL).toULong(), (0u - 1UL).toULong(), ulongArrayOf(1UL), { (0u - it).toULong() }) + expectMinMaxOf((0u - 2UL).toULong(), (0u - 1UL).toULong(), ulongArrayOf(1UL, 2UL), { (0u - it).toULong() }) + expectMinMaxOf((0u - ULong.MAX_VALUE).toULong(), (0u - 1UL).toULong(), ulongArrayOf(1UL, 2UL, ULong.MAX_VALUE), { (0u - it).toULong() }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2UL + val items = ulongArrayOf(1UL, 2UL, ULong.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2UL + val items = ulongArrayOf(1UL, 2UL, ULong.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = ulongArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: ULongArray, comparator: Comparator, selector: (ULong) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith((0u - 1UL).toULong(), (0u - 1UL).toULong(), ulongArrayOf(1UL), reverseOrder(), { (0u - it).toULong() }) + expectMinMaxOfWith((0u - 1UL).toULong(), (0u - 2UL).toULong(), ulongArrayOf(1UL, 2UL), reverseOrder(), { (0u - it).toULong() }) + expectMinMaxOfWith((0u - 1UL).toULong(), (0u - ULong.MAX_VALUE).toULong(), ulongArrayOf(1UL, 2UL, ULong.MAX_VALUE), reverseOrder(), { (0u - it).toULong() }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = ulongArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/test/generated/minmax/MinMaxUShortArrayTest.kt b/libraries/stdlib/test/generated/minmax/MinMaxUShortArrayTest.kt new file mode 100644 index 00000000000..017c5c4ecb1 --- /dev/null +++ b/libraries/stdlib/test/generated/minmax/MinMaxUShortArrayTest.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2022 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.generated.minmax + +// +// NOTE: THIS FILE IS AUTO-GENERATED by the MinMaxTestGenerator.kt +// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// + +import kotlin.math.pow +import kotlin.test.* +import test.* + +class MinMaxUShortArrayTest { + + + private fun expectMinMax(min: UShort, max: UShort, elements: UShortArray) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() { + expectMinMax(1U, 1U, ushortArrayOf(1U)) + expectMinMax(1U, 2U, ushortArrayOf(1U, 2U)) + expectMinMax(1U, UShort.MAX_VALUE, ushortArrayOf(1U, 2U, UShort.MAX_VALUE)) + + } + + @Test + fun minMaxEmpty() { + val empty = ushortArrayOf() + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } + + + + private fun expectMinMaxWith(min: UShort, max: UShort, elements: UShortArray, comparator: Comparator) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() { + expectMinMaxWith(1U, 1U, ushortArrayOf(1U), naturalOrder()) + expectMinMaxWith(1U, 2U, ushortArrayOf(1U, 2U), naturalOrder()) + expectMinMaxWith(1U, UShort.MAX_VALUE, ushortArrayOf(1U, 2U, UShort.MAX_VALUE), naturalOrder()) + + } + + @Test + fun minMaxWithEmpty() { + val empty = ushortArrayOf() + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun > expectMinMaxBy(min: UShort, max: UShort, elements: UShortArray, selector: (UShort) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() { + expectMinMaxBy(1U, 1U, ushortArrayOf(1U), { it }) + expectMinMaxBy(1U, 2U, ushortArrayOf(1U, 2U), { it }) + expectMinMaxBy(1U, UShort.MAX_VALUE, ushortArrayOf(1U, 2U, UShort.MAX_VALUE), { it }) + + } + + @Test + fun minMaxByEmpty() { + val empty = ushortArrayOf() + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = ushortArrayOf(1U, 2U, UShort.MAX_VALUE) + var c = 0 + source.minBy { c++ } + assertEquals(3, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(3, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = ushortArrayOf(1U, 2U, UShort.MAX_VALUE) + var c = 0 + source.maxBy { c++ } + assertEquals(3, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(3, c) + } + + + private inline fun > expectMinMaxOf(min: R, max: R, elements: UShortArray, selector: (UShort) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() { + expectMinMaxOf((0u - 1U).toUShort(), (0u - 1U).toUShort(), ushortArrayOf(1U), { (0u - it).toUShort() }) + expectMinMaxOf((0u - 2U).toUShort(), (0u - 1U).toUShort(), ushortArrayOf(1U, 2U), { (0u - it).toUShort() }) + expectMinMaxOf((0u - UShort.MAX_VALUE).toUShort(), (0u - 1U).toUShort(), ushortArrayOf(1U, 2U, UShort.MAX_VALUE), { (0u - it).toUShort() }) + + } + + @Test + fun minMaxOfDouble() { + val middle = 2U + val items = ushortArrayOf(1U, 2U, UShort.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = 2U + val items = ushortArrayOf(1U, 2U, UShort.MAX_VALUE).apply { shuffle() } + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = ushortArrayOf() + + assertNull(empty.minOfOrNull { it.toString() }) + assertNull(empty.maxOfOrNull { it.toString() }) + assertFailsWith { empty.minOf { it.toString() } } + assertFailsWith { empty.maxOf { it.toString() } } + + + assertNull(empty.minOfOrNull { 0.0 }) + assertNull(empty.maxOfOrNull { 0.0 }) + assertFailsWith { empty.minOf { 0.0 } } + assertFailsWith { empty.maxOf { 0.0 } } + + + assertNull(empty.minOfOrNull { 0.0F }) + assertNull(empty.maxOfOrNull { 0.0F }) + assertFailsWith { empty.minOf { 0.0F } } + assertFailsWith { empty.maxOf { 0.0F } } + + + } + + + private inline fun expectMinMaxOfWith(min: R, max: R, elements: UShortArray, comparator: Comparator, selector: (UShort) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() { + expectMinMaxOfWith((0u - 1U).toUShort(), (0u - 1U).toUShort(), ushortArrayOf(1U), reverseOrder(), { (0u - it).toUShort() }) + expectMinMaxOfWith((0u - 1U).toUShort(), (0u - 2U).toUShort(), ushortArrayOf(1U, 2U), reverseOrder(), { (0u - it).toUShort() }) + expectMinMaxOfWith((0u - 1U).toUShort(), (0u - UShort.MAX_VALUE).toUShort(), ushortArrayOf(1U, 2U, UShort.MAX_VALUE), reverseOrder(), { (0u - it).toUShort() }) + + } + + @Test + fun minMaxOfWithEmpty() { + val empty = ushortArrayOf() + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } + +} diff --git a/libraries/stdlib/wasm/build.gradle.kts b/libraries/stdlib/wasm/build.gradle.kts index 4488bad00e7..01d2e9aa3a1 100644 --- a/libraries/stdlib/wasm/build.gradle.kts +++ b/libraries/stdlib/wasm/build.gradle.kts @@ -62,6 +62,9 @@ val commonTestSources by task { sources.forEach { path -> from("$rootDir/$path") { into(path.dropLastWhile { it != '/' }) + // exclusions due to KT-51647 + exclude("generated/minmax") + exclude("collections/MapTest.kt") } } diff --git a/libraries/tools/kotlin-stdlib-gen/build.gradle b/libraries/tools/kotlin-stdlib-gen/build.gradle index c4bc60252e0..7f5f5e70720 100644 --- a/libraries/tools/kotlin-stdlib-gen/build.gradle +++ b/libraries/tools/kotlin-stdlib-gen/build.gradle @@ -36,6 +36,14 @@ task run(type: JavaExec) { systemProperty 'line.separator', '\n' } +task generateStdlibTests(type: JavaExec) { + group 'application' + main 'generators.GenerateStandardLibTestsKt' + classpath sourceSets.main.runtimeClasspath + args = ["${rootDir}"] + systemProperty 'line.separator', '\n' +} + task generateUnicodeData(type: JavaExec) { group 'application' main 'generators.unicode.GenerateUnicodeDataKt' diff --git a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLibTests.kt b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLibTests.kt new file mode 100644 index 00000000000..643e5e94ab6 --- /dev/null +++ b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLibTests.kt @@ -0,0 +1,13 @@ +/* + * Copyright 2010-2022 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 generators + +import generators.test.MinMaxTestGenerator + + +fun main() { + MinMaxTestGenerator.generate() +} \ No newline at end of file diff --git a/libraries/tools/kotlin-stdlib-gen/src/generators/test/MinMaxTestGenerator.kt b/libraries/tools/kotlin-stdlib-gen/src/generators/test/MinMaxTestGenerator.kt new file mode 100644 index 00000000000..c9dac2f14ad --- /dev/null +++ b/libraries/tools/kotlin-stdlib-gen/src/generators/test/MinMaxTestGenerator.kt @@ -0,0 +1,358 @@ +/* + * Copyright 2010-2022 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 generators.test + +import templates.* +import templates.Family.* +import templates.PrimitiveType +import java.io.File + +object MinMaxTestGenerator { + fun generate() { + generate(Iterables) + generate(Sequences) + generate(CharSequences) + generate(ArraysOfObjects) + for (primitive in PrimitiveType.defaultPrimitives - PrimitiveType.Boolean) { + generate(ArraysOfPrimitives, primitive) + } + for (primitive in PrimitiveType.unsignedPrimitives) { + generate(ArraysOfUnsigned, primitive) + } + } + + + + private fun elements(elementType: String) = when (elementType) { + "Int", "Byte", "Short", "Long" -> listOf("1", "2", "$elementType.MAX_VALUE") + "UInt", "UByte", "UShort" -> listOf("1U", "2U", "$elementType.MAX_VALUE") + "ULong" -> listOf("1UL", "2UL", "$elementType.MAX_VALUE") + "Double" -> listOf("1.0", "2.0", "$elementType.POSITIVE_INFINITY") + "Float" -> listOf("1.0F", "2.0F", "$elementType.POSITIVE_INFINITY") + "Char" -> listOf("'a'", "'b'", "$elementType.MAX_VALUE") + "T" -> listOf("a", "bcd", "e").map { "\"$it\"" } + else -> error(elementType) + } + + private fun generate(family: Family, primitive: PrimitiveType? = null) { + val containerClass = when(family) { + Iterables, Sequences, CharSequences -> family.toString().dropLast(1) + ArraysOfObjects -> "Array" + ArraysOfPrimitives, ArraysOfUnsigned -> "${primitive!!}Array" + else -> error(family) + } + + val isGeneric = family in listOf(Iterables, Sequences, ArraysOfObjects) + + val elementType = when { + isGeneric -> "T" + family == CharSequences -> "Char" + else -> primitive!!.toString() + } + val defaultElements = elements(elementType) + + val containerType = containerClass + "".ifOrEmpty(isGeneric) + + fun emptyContainer(elementType: String): String { + val type = if (elementType == "T") "Int" else elementType + return when (family) { + CharSequences -> "StringBuilder()" + Iterables -> "listOf<$type>()" + Sequences -> "sequenceOf<$type>()" + ArraysOfObjects -> "arrayOf<$type>()" + else -> "${containerClass.let { it.substring(0, 2).lowercase() + it.substring(2) }}Of()" + } + } + + + + fun containerOf(elements: List, shuffle: Boolean = false): String { + require(elements.isNotEmpty()) + val args = elements.joinToString() + val shuffled = when (family) { + ArraysOfObjects, ArraysOfPrimitives, ArraysOfUnsigned, CharSequences -> ".apply { shuffle() }" + else -> ".shuffled()" + } + return when (family) { + CharSequences -> "StringBuilder(charArrayOf($args)${shuffled.ifOrEmpty(shuffle)}.concatToString())" + Iterables -> "listOf($args)${shuffled.ifOrEmpty(shuffle)}" + else -> "${containerClass.let { it.substring(0, 2).lowercase() + it.substring(2) }}Of($args)${shuffled.ifOrEmpty(shuffle)}" + } + } + + val className = "MinMax${containerClass}Test" + val file = File("libraries/stdlib/test/generated/minmax/$className.kt") + file.bufferedWriter().use { writer -> + + writer.appendLine(COPYRIGHT_NOTICE) + writer.appendLine() + writer.appendLine("package test.generated.minmax") + writer.appendLine() + writer.appendLine(autoGeneratedWarning("MinMaxTestGenerator.kt")) + writer.appendLine() + writer.appendLine("import kotlin.math.pow") + writer.appendLine("import kotlin.test.*") + writer.appendLine("import test.*") + writer.appendLine() + writer.appendLine("class $className {") + writer.appendLine(""" + + private fun ${"> ".ifOrEmpty(isGeneric)}expectMinMax(min: $elementType, max: $elementType, elements: $containerType) { + assertEquals(min, elements.minOrNull()) + assertEquals(max, elements.maxOrNull()) + assertEquals(min, elements.min()) + assertEquals(max, elements.max()) + } + + @Test + fun minMax() {""") + + for (size in 1..3) { + val elements = defaultElements.take(size) + writer.appendLine(" expectMinMax(${elements.first()}, ${elements.last()}, ${containerOf(elements)})") + } + + if (isGeneric) { + for (type in listOf(PrimitiveType.Int, PrimitiveType.Long, PrimitiveType.UInt, PrimitiveType.Char)) { + val elements = elements(type.toString()) + writer.appendLine(" expectMinMax(${elements.first()}, ${elements.last()}, ${containerOf(elements)})") + } + } + + writer.appendLine( +""" + } + + @Test + fun minMaxEmpty() { + val empty = ${emptyContainer(elementType)} + assertNull(empty.minOrNull()) + assertNull(empty.maxOrNull()) + assertFailsWith { empty.min() } + assertFailsWith { empty.max() } + } +""") + run { + val assertions = """ + assertIsNegativeZero(zeroes.min().toDouble()) + assertIsNegativeZero(zeroes.minOrNull()!!.toDouble()) + assertTrue(NaNs.min().isNaN()) + assertTrue(NaNs.minOrNull()!!.isNaN()) + + assertIsPositiveZero(zeroes.max().toDouble()) + assertIsPositiveZero(zeroes.maxOrNull()!!.toDouble()) + assertTrue(NaNs.max().isNaN()) + assertTrue(NaNs.maxOrNull()!!.isNaN()) +""" + if (isGeneric || primitive == PrimitiveType.Double) { + writer.appendLine(""" + @Test + fun minMaxDouble() { + val zeroes = ${containerOf(listOf("0.0", "-0.0"), shuffle = true)} + val NaNs = ${containerOf(listOf("0.0", "Double.NaN"), shuffle = true)} +$assertions + } +""") + } + if (isGeneric || primitive == PrimitiveType.Float) { + writer.appendLine(""" + @Test + fun minMaxFloat() { + val zeroes = ${containerOf(listOf("0.0F", "-0.0F"), shuffle = true)} + val NaNs = ${containerOf(listOf("0.0F", "Float.NaN"), shuffle = true)} +$assertions + } +""") + } + } + writer.appendLine(""" + + private fun ${" ".ifOrEmpty(isGeneric)}expectMinMaxWith(min: $elementType, max: $elementType, elements: $containerType, comparator: Comparator<$elementType>) { + assertEquals(min, elements.minWithOrNull(comparator)) + assertEquals(max, elements.maxWithOrNull(comparator)) + assertEquals(min, elements.minWith(comparator)) + assertEquals(max, elements.maxWith(comparator)) + } + + @Test + fun minMaxWith() {""") + for (size in 1..3) { + val elements = defaultElements.take(size) + writer.appendLine(" expectMinMaxWith(${elements.first()}, ${elements.last()}, ${containerOf(elements)}, naturalOrder())") + } + if (isGeneric) { + val elements = listOf("a", "B").map { "\"$it\"" } + writer.appendLine(" expectMinMaxWith(${elements.first()}, ${elements.last()}, ${containerOf(elements)}, String.CASE_INSENSITIVE_ORDER)") + } + writer.appendLine(""" + } + + @Test + fun minMaxWithEmpty() { + val empty = ${emptyContainer(elementType)} + assertNull(empty.minWithOrNull(naturalOrder())) + assertNull(empty.maxWithOrNull(naturalOrder())) + assertFailsWith { empty.minWith(naturalOrder()) } + assertFailsWith { empty.maxWith(naturalOrder()) } + } + + + private inline fun <${"T, ".ifOrEmpty(isGeneric)}K : Comparable> expectMinMaxBy(min: $elementType, max: $elementType, elements: $containerType, selector: ($elementType) -> K) { + assertEquals(min, elements.minBy(selector)) + assertEquals(min, elements.minByOrNull(selector)) + assertEquals(max, elements.maxBy(selector)) + assertEquals(max, elements.maxByOrNull(selector)) + } + + @Test + fun minMaxBy() {""") + for (size in 1..3) { + val elements = defaultElements.take(size) + writer.appendLine(" expectMinMaxBy(${elements.first()}, ${elements.last()}, ${containerOf(elements)}, { it })") + } + if (isGeneric) { + val elements = listOf("abc", "De").map { "\"$it\"" } + writer.appendLine(" expectMinMaxBy(${elements.last()}, ${elements.first()}, ${containerOf(elements)}, { it.length })") + } + writer.appendLine(""" + } + + @Test + fun minMaxByEmpty() { + val empty = ${emptyContainer(elementType)} + assertNull(empty.minByOrNull { it.toString() }) + assertNull(empty.maxByOrNull { it.toString() }) + assertFailsWith { empty.minBy { it.toString() } } + assertFailsWith { empty.maxBy { it.toString() } } + } + + @Test + fun minBySelectorEvaluateOnce() { + val source = ${containerOf(defaultElements)} + var c = 0 + source.minBy { c++ } + assertEquals(${defaultElements.size}, c) + c = 0 + source.minByOrNull { c++ } + assertEquals(${defaultElements.size}, c) + } + + @Test + fun maxBySelectorEvaluateOnce() { + val source = ${containerOf(defaultElements)} + var c = 0 + source.maxBy { c++ } + assertEquals(${defaultElements.size}, c) + c = 0 + source.maxByOrNull { c++ } + assertEquals(${defaultElements.size}, c) + } + + + private inline fun <${"T, ".ifOrEmpty(isGeneric)}R : Comparable> expectMinMaxOf(min: R, max: R, elements: $containerType, selector: ($elementType) -> R) { + assertEquals(min, elements.minOf(selector)) + assertEquals(min, elements.minOfOrNull(selector)) + assertEquals(max, elements.maxOf(selector)) + assertEquals(max, elements.maxOfOrNull(selector)) + } + + @Test + fun minMaxOf() {""") + for (size in 1..3) { + val elements = defaultElements.take(size) + if (primitive?.isNumeric() == true) { + writer.appendLine(" expectMinMaxOf(-${elements.last()}, -${elements.first()}, ${containerOf(elements)}, { -it })") + } else if (primitive?.isUnsigned() == true) { + writer.appendLine(" expectMinMaxOf((0u - ${elements.last()}).to$primitive(), (0u - ${elements.first()}).to$primitive(), ${containerOf(elements)}, { (0u - it).to$primitive() })") + } else { + writer.appendLine(" expectMinMaxOf(\"_\" + ${elements.first()}, \"_\" + ${elements.last()}, ${containerOf(elements)}, { \"_\$it\" })") + } + } + writer.appendLine(""" + } + + @Test + fun minMaxOfDouble() { + val middle = ${defaultElements[1]} + val items = ${containerOf(defaultElements, shuffle = true)} + assertTrue(items.minOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toDouble().pow(0.5) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toDouble().pow(0.5) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0 }) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0 }!!) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0 }) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0 }!!) + } + + @Test + fun minMaxOfFloat() { + val middle = ${defaultElements[1]} + val items = ${containerOf(defaultElements, shuffle = true)} + assertTrue(items.minOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.minOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + assertTrue(items.maxOf { it.compareTo(middle).toFloat().pow(0.5F) }.isNaN()) + assertTrue(items.maxOfOrNull { it.compareTo(middle).toFloat().pow(0.5F) }!!.isNaN()) + + assertIsNegativeZero(items.minOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsNegativeZero(items.minOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + assertIsPositiveZero(items.maxOf { it.compareTo(middle) * 0.0F }.toDouble()) + assertIsPositiveZero(items.maxOfOrNull { it.compareTo(middle) * 0.0F }!!.toDouble()) + } + + @Test + fun minMaxOfEmpty() { + val empty = ${emptyContainer(elementType)}""") + for (selector in listOf("it.toString()", "0.0", "0.0F")) { + writer.appendLine(""" + assertNull(empty.minOfOrNull { $selector }) + assertNull(empty.maxOfOrNull { $selector }) + assertFailsWith { empty.minOf { $selector } } + assertFailsWith { empty.maxOf { $selector } } +""") + } + writer.appendLine(""" + } + + + private inline fun <${"T, ".ifOrEmpty(isGeneric)}R> expectMinMaxOfWith(min: R, max: R, elements: $containerType, comparator: Comparator, selector: ($elementType) -> R) { + assertEquals(min, elements.minOfWith(comparator, selector)) + assertEquals(min, elements.minOfWithOrNull(comparator, selector)) + assertEquals(max, elements.maxOfWith(comparator, selector)) + assertEquals(max, elements.maxOfWithOrNull(comparator, selector)) + } + + @Test + fun minMaxOfWith() {""") + for (size in 1..3) { + val elements = defaultElements.take(size) + if (primitive?.isNumeric() == true) { + writer.appendLine(" expectMinMaxOfWith(-${elements.first()}, -${elements.last()}, ${containerOf(elements)}, reverseOrder(), { -it })") + } else if (primitive?.isUnsigned() == true) { + writer.appendLine(" expectMinMaxOfWith((0u - ${elements.first()}).to$primitive(), (0u - ${elements.last()}).to$primitive(), ${containerOf(elements)}, reverseOrder(), { (0u - it).to$primitive() })") + } else { + writer.appendLine(" expectMinMaxOfWith(\"_\" + ${elements.last()}, \"_\" + ${elements.first()}, ${containerOf(elements)}, reverseOrder(), { \"_\$it\" })") + } + } + writer.appendLine(""" + } + + @Test + fun minMaxOfWithEmpty() { + val empty = ${emptyContainer(elementType)} + assertNull(empty.minOfWithOrNull(naturalOrder()) { it.toString() }) + assertNull(empty.maxOfWithOrNull(naturalOrder()) { it.toString() }) + assertFailsWith { empty.minOfWith(naturalOrder()) { it.toString() } } + assertFailsWith { empty.maxOfWith(naturalOrder()) { it.toString() } } + } +""") + writer.appendLine("}") + } + + } + +}