Add manually written tests covering both min/max/By/With and their nullable variants

libraries/stdlib/test/collections/ArraysTest.kt

diff --git a/libraries/stdlib/test/collections/ArraysTest.kt b/libraries/stdlib/test/collections/ArraysTest.kt
index 42d6e13..3bcf8f0 100644
--- a/libraries/stdlib/test/collections/ArraysTest.kt
+++ b/libraries/stdlib/test/collections/ArraysTest.kt
@@ -7,10 +7,11 @@
 
 package test.collections
 
+import test.assertIsNegativeZero
+import test.assertIsPositiveZero
 import test.assertStaticTypeIs
 import test.assertTypeEquals
 import test.collections.behaviors.*
-import test.comparisons.STRING_CASE_INSENSITIVE_ORDER
 import test.text.isAsciiLetter
 import kotlin.test.*
 import kotlin.random.Random
@@ -347,15 +348,164 @@
 
 
 
-    @Test fun minOrNull() {
-        expect(null, { arrayOf<Int>().minOrNull() })
-        expect(1, { arrayOf(1).minOrNull() })
-        expect(2, { arrayOf(2, 3).minOrNull() })
-        expect(2000000000000, { arrayOf(3000000000000, 2000000000000).minOrNull() })
-        expect('a', { arrayOf('a', 'b').minOrNull() })
-        expect("a", { arrayOf("a", "b").minOrNull() })
+
+    @Test
+    fun minMax() = with(MinMaxOperations.ArrayT) {
+        expectMinMax(1, 1, arrayOf(1))
+        expectMinMax(2, 3, arrayOf(2, 3))
+        expectMinMax(2, 3, arrayOf(3, 2))
+        expectMinMax(2000000000000, 3000000000000, arrayOf(3000000000000, 2000000000000))
+        expectMinMax('a', 'b', arrayOf('a', 'b'))
+        expectMinMax("a", "b", arrayOf("a", "b"))
+
+        MinMaxOperations.ArrayT<Int>().expectMinMaxEmpty(emptyArray())
     }
 
+    @Test
+    fun minMaxIntArray() = with(MinMaxOperations.AInt) {
+        expectMinMaxEmpty(intArrayOf())
+        expectMinMax(1, 1, intArrayOf(1))
+        expectMinMax(1, 2, intArrayOf(1, 2))
+    }
+
+    @Test
+    fun minMaxLongArray() = with(MinMaxOperations.ALong) {
+        expectMinMaxEmpty(longArrayOf())
+        expectMinMax(1, 1, longArrayOf(1))
+        expectMinMax(1, 2, longArrayOf(1, 2))
+    }
+
+    @Test
+    fun minMaxShortArray() = with(MinMaxOperations.AShort) {
+        expectMinMaxEmpty(shortArrayOf())
+        expectMinMax(1, 1, shortArrayOf(1))
+        expectMinMax(1, 2, shortArrayOf(1, 2))
+    }
+
+    @Test
+    fun minMaxByteArray() = with(MinMaxOperations.AByte) {
+        expectMinMaxEmpty(byteArrayOf())
+        expectMinMax(1, 1, byteArrayOf(1))
+        expectMinMax(1, 2, byteArrayOf(1, 2))
+    }
+
+    @Test
+    fun minMaxFloatArray() = with(MinMaxOperations.AFloat) {
+        expectMinMaxEmpty(floatArrayOf())
+        expectMinMax(1F, 1F, floatArrayOf(1F))
+        expectMinMax(1F, 2F, floatArrayOf(1F, 2F))
+    }
+    
+    @Test
+    fun minMaxDoubleArray() = with(MinMaxOperations.ADouble) {
+        expectMinMaxEmpty(doubleArrayOf())
+        expectMinMax(1.0, 1.0, doubleArrayOf(1.0))
+        expectMinMax(1.0, 2.0, doubleArrayOf(1.0, 2.0))
+    }
+
+    @Test
+    fun minMaxCharArray() = with(MinMaxOperations.AChar) {
+        expectMinMaxEmpty(charArrayOf())
+        expectMinMax('a', 'a', charArrayOf('a'))
+        expectMinMax('a', 'b', charArrayOf('a', 'b'))
+    }
+
+    @Test
+    fun minMaxFloatingPoint() {
+        val doubleZeroes = arrayOf(0.0, -0.0).also { it.shuffle() }
+        val floatZeroes = arrayOf(0.0F, -0.0F).also { it.shuffle() }
+        val doubleNaN = arrayOf(0.0, Double.NaN).also { it.shuffle() }
+        val floatNaN = arrayOf(0.0F, Float.NaN).also { it.shuffle() }
+
+        assertIsNegativeZero(doubleZeroes.min())
+        assertIsNegativeZero(doubleZeroes.minOrNull()!!)
+        assertIsNegativeZero(floatZeroes.min().toDouble())
+        assertIsNegativeZero(floatZeroes.minOrNull()!!.toDouble())
+        assertTrue(doubleNaN.min().isNaN())
+        assertTrue(doubleNaN.minOrNull()!!.isNaN())
+        assertTrue(floatNaN.min().isNaN())
+        assertTrue(floatNaN.minOrNull()!!.isNaN())
+
+        assertIsPositiveZero(doubleZeroes.max())
+        assertIsPositiveZero(doubleZeroes.maxOrNull()!!)
+        assertIsPositiveZero(floatZeroes.max().toDouble())
+        assertIsPositiveZero(floatZeroes.maxOrNull()!!.toDouble())
+        assertTrue(doubleNaN.max().isNaN())
+        assertTrue(doubleNaN.maxOrNull()!!.isNaN())
+        assertTrue(floatNaN.max().isNaN())
+        assertTrue(floatNaN.maxOrNull()!!.isNaN())
+    }
+
+    @Test
+    fun minMaxPrimitiveFloatingPoint() {
+        val doubleZeroes = doubleArrayOf(0.0, -0.0).also { it.shuffle() }
+        val floatZeroes = floatArrayOf(0.0F, -0.0F).also { it.shuffle() }
+        val doubleNaN = doubleArrayOf(0.0, Double.NaN).also { it.shuffle() }
+        val floatNaN = floatArrayOf(0.0F, Float.NaN).also { it.shuffle() }
+
+        assertIsNegativeZero(doubleZeroes.min())
+        assertIsNegativeZero(doubleZeroes.minOrNull()!!)
+        assertIsNegativeZero(floatZeroes.min().toDouble())
+        assertIsNegativeZero(floatZeroes.minOrNull()!!.toDouble())
+        assertTrue(doubleNaN.min().isNaN())
+        assertTrue(doubleNaN.minOrNull()!!.isNaN())
+        assertTrue(floatNaN.min().isNaN())
+        assertTrue(floatNaN.minOrNull()!!.isNaN())
+
+        assertIsPositiveZero(doubleZeroes.max())
+        assertIsPositiveZero(doubleZeroes.maxOrNull()!!)
+        assertIsPositiveZero(floatZeroes.max().toDouble())
+        assertIsPositiveZero(floatZeroes.maxOrNull()!!.toDouble())
+        assertTrue(doubleNaN.max().isNaN())
+        assertTrue(doubleNaN.maxOrNull()!!.isNaN())
+        assertTrue(floatNaN.max().isNaN())
+        assertTrue(floatNaN.maxOrNull()!!.isNaN())
+    }
+
+//    private fun <T> expectMinMaxWith(min: T, max: T, elements: Array<T>, comparator: Comparator<T>) {
+//        assertEquals(min, elements.minWithOrNull(comparator))
+//        assertEquals(max, elements.maxWithOrNull(comparator))
+//        assertEquals(min, elements.minWith(comparator))
+//        assertEquals(max, elements.maxWith(comparator))
+//    }
+
+    @Test
+    fun minMaxWith() = with(MinMaxOperationsWith.ArrayT) {
+        expectMinMaxWith(1, 1, arrayOf(1), naturalOrder())
+        expectMinMaxWith("a", "B", arrayOf("a", "B"), String.CASE_INSENSITIVE_ORDER)
+    }
+
+    @Test
+    fun minMaxWithEmpty() = with(MinMaxOperationsWith.ArrayT<Int>()) {
+        expectMinMaxWithEmpty(emptyArray(), naturalOrder())
+    }
+
+    private inline fun <T, K : Comparable<K>> expectMinMaxBy(min: T, max: T, elements: Array<T>, selector: (T) -> K) {
+        assertEquals(min, elements.minBy(selector))
+        assertEquals(min, elements.minByOrNull(selector))
+        assertEquals(max, elements.maxByOrNull(selector))
+        assertEquals(max, elements.maxByOrNull(selector))
+    }
+
+    @Test
+    fun minMaxBy() {
+        expectMinMaxBy(1, 1, arrayOf(1), { it })
+        expectMinMaxBy(3, 2, arrayOf(2, 3), { -it })
+        expectMinMaxBy('a', 'b', arrayOf('a', 'b'), { "x$it" })
+        expectMinMaxBy("b", "abc", arrayOf("abc", "b"), { it.length })
+    }
+
+    @Test
+    fun minMaxByEmpty() {
+        val empty = emptyArray<Int>()
+        val selector = Int::toString
+        assertNull(empty.minByOrNull(selector))
+        assertNull(empty.maxByOrNull(selector))
+        assertFailsWith<NoSuchElementException> { empty.minBy(selector) }
+        assertFailsWith<NoSuchElementException> { empty.maxBy(selector) }
+    }
+
+
     @Test fun minOrNullInPrimitiveArrays() {
         expect(null, { intArrayOf().minOrNull() })
         expect(1, { intArrayOf(1).minOrNull() })
@@ -368,14 +518,6 @@
         expect('a', { charArrayOf('a', 'b').minOrNull() })
     }
 
-    @Test fun maxOrNull() {
-        expect(null, { arrayOf<Int>().maxOrNull() })
-        expect(1, { arrayOf(1).maxOrNull() })
-        expect(3, { arrayOf(2, 3).maxOrNull() })
-        expect(3000000000000, { arrayOf(3000000000000, 2000000000000).maxOrNull() })
-        expect('b', { arrayOf('a', 'b').maxOrNull() })
-        expect("b", { arrayOf("a", "b").maxOrNull() })
-    }
 
     @Test fun maxOrNullInPrimitiveArrays() {
         expect(null, { intArrayOf().maxOrNull() })
@@ -389,10 +531,6 @@
         expect('b', { charArrayOf('a', 'b').maxOrNull() })
     }
 
-    @Test fun minWithOrNull() {
-        assertEquals(null, arrayOf<Int>().minWithOrNull(naturalOrder()))
-        assertEquals("a", arrayOf("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER))
-    }
 
     @Test fun minWithOrNullInPrimitiveArrays() {
         expect(null, { intArrayOf().minWithOrNull(naturalOrder()) })
@@ -400,25 +538,12 @@
         expect(4, { intArrayOf(2, 3, 4).minWithOrNull(compareBy { it % 4 }) })
     }
 
-    @Test fun maxWithOrNull() {
-        assertEquals(null, arrayOf<Int>().maxWithOrNull(naturalOrder()))
-        assertEquals("B", arrayOf("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER))
-    }
-
     @Test fun maxWithOrNullInPrimitiveArrays() {
         expect(null, { intArrayOf().maxWithOrNull(naturalOrder()) })
         expect(1, { intArrayOf(1).maxWithOrNull(naturalOrder()) })
         expect(-4, { intArrayOf(2, 3, -4).maxWithOrNull(compareBy { it * it }) })
     }
 
-    @Test fun minByOrNull() {
-        expect(null, { arrayOf<Int>().minByOrNull { it } })
-        expect(1, { arrayOf(1).minByOrNull { it } })
-        expect(3, { arrayOf(2, 3).minByOrNull { -it } })
-        expect('a', { arrayOf('a', 'b').minByOrNull { "x$it" } })
-        expect("b", { arrayOf("b", "abc").minByOrNull { it.length } })
-    }
-
     @Test fun minByOrNullInPrimitiveArrays() {
         expect(null, { intArrayOf().minByOrNull { it } })
         expect(1, { intArrayOf(1).minByOrNull { it } })
@@ -430,14 +555,6 @@
         expect(2.0, { doubleArrayOf(2.0, 3.0).minByOrNull { it * it } })
     }
 
-    @Test fun maxByOrNull() {
-        expect(null, { arrayOf<Int>().maxByOrNull { it } })
-        expect(1, { arrayOf(1).maxByOrNull { it } })
-        expect(2, { arrayOf(2, 3).maxByOrNull { -it } })
-        expect('b', { arrayOf('a', 'b').maxByOrNull { "x$it" } })
-        expect("abc", { arrayOf("b", "abc").maxByOrNull { it.length } })
-    }
-
     @Test fun maxByOrNullInPrimitiveArrays() {
         expect(null, { intArrayOf().maxByOrNull { it } })
         expect(1, { intArrayOf(1).maxByOrNull { it } })

libraries/stdlib/test/collections/CollectionTest.kt

diff --git a/libraries/stdlib/test/collections/CollectionTest.kt b/libraries/stdlib/test/collections/CollectionTest.kt
index 193ed2a..fd1ed1e 100644
--- a/libraries/stdlib/test/collections/CollectionTest.kt
+++ b/libraries/stdlib/test/collections/CollectionTest.kt
@@ -10,7 +10,6 @@
 import test.assertStaticAndRuntimeTypeIs
 import kotlin.test.*
 import test.collections.behaviors.*
-import test.comparisons.STRING_CASE_INSENSITIVE_ORDER
 import kotlin.math.pow
 import kotlin.random.Random
 
@@ -833,66 +832,104 @@
         assertTrue(hashSetOf(45, 14, 13).toIterable().contains(14))
     }
 
-    @Test fun minOrNull() {
-        expect(null, { listOf<Int>().minOrNull() })
-        expect(1, { listOf(1).minOrNull() })
-        expect(2, { listOf(2, 3).minOrNull() })
-        expect(2000000000000, { listOf(3000000000000, 2000000000000).minOrNull() })
-        expect('a', { listOf('a', 'b').minOrNull() })
-        expect("a", { listOf("a", "b").minOrNull() })
-        expect(null, { listOf<Int>().asSequence().minOrNull() })
-        expect(2, { listOf(2, 3).asSequence().minOrNull() })
 
-        assertIsNegativeZero(listOf(0.0, -0.0).shuffled().minOrNull()!!)
-        assertIsNegativeZero(listOf(0.0F, -0.0F).shuffled().minOrNull()!!.toDouble())
+    private fun <T : Comparable<T>> expectMinMax(min: T, max: T, elements: Iterable<T>) {
+        assertEquals(min, elements.minOrNull())
+        assertEquals(max, elements.maxOrNull())
+        assertEquals(min, elements.min())
+        assertEquals(max, elements.max())
     }
 
-    @Test fun max() {
-        expect(null, { listOf<Int>().maxOrNull() })
-        expect(1, { listOf(1).maxOrNull() })
-        expect(3, { listOf(2, 3).maxOrNull() })
-        expect(3000000000000, { listOf(3000000000000, 2000000000000).maxOrNull() })
-        expect('b', { listOf('a', 'b').maxOrNull() })
-        expect("b", { listOf("a", "b").maxOrNull() })
-        expect(null, { listOf<Int>().asSequence().maxOrNull() })
-        expect(3, { listOf(2, 3).asSequence().maxOrNull() })
-
-        assertIsPositiveZero(listOf(0.0, -0.0).shuffled().maxOrNull()!!)
-        assertIsPositiveZero(listOf(0.0F, -0.0F).shuffled().maxOrNull()!!.toDouble())
+    @Test
+    fun minMax() {
+        expectMinMax(1, 1, listOf(1))
+        expectMinMax(2, 3, listOf(2, 3))
+        expectMinMax(2, 3, listOf(3, 2))
+        expectMinMax(2000000000000, 3000000000000, listOf(3000000000000, 2000000000000))
+        expectMinMax('a', 'b', listOf('a', 'b'))
+        expectMinMax("a", "b", listOf("a", "b"))
     }
 
-    @Test fun minWithOrNull() {
-        expect(null, { listOf<Int>().minWithOrNull(naturalOrder()) })
-        expect(1, { listOf(1).minWithOrNull(naturalOrder()) })
-        expect("a", { listOf("a", "B").minWithOrNull(STRING_CASE_INSENSITIVE_ORDER) })
-        expect("a", { listOf("a", "B").asSequence().minWithOrNull(STRING_CASE_INSENSITIVE_ORDER) })
+    @Test
+    fun minMaxEmpty() {
+        val empty = emptyList<Int>()
+        assertNull(empty.minOrNull())
+        assertNull(empty.maxOrNull())
+        assertFailsWith<NoSuchElementException> { empty.min() }
+        assertFailsWith<NoSuchElementException> { empty.max() }
     }
 
-    @Test fun maxWithOrNull() {
-        expect(null, { listOf<Int>().maxWithOrNull(naturalOrder()) })
-        expect(1, { listOf(1).maxWithOrNull(naturalOrder()) })
-        expect("B", { listOf("a", "B").maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER) })
-        expect("B", { listOf("a", "B").asSequence().maxWithOrNull(STRING_CASE_INSENSITIVE_ORDER) })
+    @Test
+    fun minMaxFloatingPoint() {
+        val doubleZeroes = listOf(0.0, -0.0)
+        val floatZeroes = listOf(0.0F, -0.0F)
+        val doubleNaN = listOf(0.0, Double.NaN)
+        val floatNaN = listOf(0.0F, Float.NaN)
+
+        assertIsNegativeZero(doubleZeroes.shuffled().min())
+        assertIsNegativeZero(doubleZeroes.shuffled().minOrNull()!!)
+        assertIsNegativeZero(floatZeroes.shuffled().min().toDouble())
+        assertIsNegativeZero(floatZeroes.shuffled().minOrNull()!!.toDouble())
+        assertTrue(doubleNaN.shuffled().min().isNaN())
+        assertTrue(doubleNaN.shuffled().minOrNull()!!.isNaN())
+        assertTrue(floatNaN.shuffled().min().isNaN())
+        assertTrue(floatNaN.shuffled().minOrNull()!!.isNaN())
+
+        assertIsPositiveZero(doubleZeroes.shuffled().max())
+        assertIsPositiveZero(doubleZeroes.shuffled().maxOrNull()!!)
+        assertIsPositiveZero(floatZeroes.shuffled().max().toDouble())
+        assertIsPositiveZero(floatZeroes.shuffled().maxOrNull()!!.toDouble())
+        assertTrue(doubleNaN.shuffled().max().isNaN())
+        assertTrue(doubleNaN.shuffled().maxOrNull()!!.isNaN())
+        assertTrue(floatNaN.shuffled().max().isNaN())
+        assertTrue(floatNaN.shuffled().maxOrNull()!!.isNaN())
     }
 
-    @Test fun minByOrNull() {
-        expect(null, { listOf<Int>().minByOrNull { it } })
-        expect(1, { listOf(1).minByOrNull { it } })
-        expect(3, { listOf(2, 3).minByOrNull { -it } })
-        expect('a', { listOf('a', 'b').minByOrNull { "x$it" } })
-        expect("b", { listOf("b", "abc").minByOrNull { it.length } })
-        expect(null, { listOf<Int>().asSequence().minByOrNull { it } })
-        expect(3, { listOf(2, 3).asSequence().minByOrNull { -it } })
+    private fun <T> expectMinMaxWith(min: T, max: T, elements: Iterable<T>, comparator: Comparator<T>) {
+        assertEquals(min, elements.minWithOrNull(comparator))
+        assertEquals(max, elements.maxWithOrNull(comparator))
+        assertEquals(min, elements.minWith(comparator))
+        assertEquals(max, elements.maxWith(comparator))
     }
 
-    @Test fun maxByOrNull() {
-        expect(null, { listOf<Int>().maxByOrNull { it } })
-        expect(1, { listOf(1).maxByOrNull { it } })
-        expect(2, { listOf(2, 3).maxByOrNull { -it } })
-        expect('b', { listOf('a', 'b').maxByOrNull { "x$it" } })
-        expect("abc", { listOf("b", "abc").maxByOrNull { it.length } })
-        expect(null, { listOf<Int>().asSequence().maxByOrNull { it } })
-        expect(2, { listOf(2, 3).asSequence().maxByOrNull { -it } })
+    @Test
+    fun minMaxWith() {
+        expectMinMaxWith(1, 1, listOf(1), naturalOrder())
+        expectMinMaxWith("a", "B", listOf("a", "B"), String.CASE_INSENSITIVE_ORDER)
+    }
+
+    @Test
+    fun minMaxWithEmpty() {
+        val empty = emptyList<Int>()
+        assertNull(empty.minWithOrNull(naturalOrder()))
+        assertNull(empty.maxWithOrNull(naturalOrder()))
+        assertFailsWith<NoSuchElementException> { empty.minWith(naturalOrder()) }
+        assertFailsWith<NoSuchElementException> { empty.maxWith(naturalOrder()) }
+    }
+
+    private inline fun <T, K : Comparable<K>> expectMinMaxBy(min: T, max: T, elements: Iterable<T>, selector: (T) -> K) {
+        assertEquals(min, elements.minBy(selector))
+        assertEquals(min, elements.minByOrNull(selector))
+        assertEquals(max, elements.maxByOrNull(selector))
+        assertEquals(max, elements.maxByOrNull(selector))
+    }
+
+    @Test
+    fun minMaxBy() {
+        expectMinMaxBy(1, 1, listOf(1), { it })
+        expectMinMaxBy(3, 2, listOf(2, 3), { -it })
+        expectMinMaxBy('a', 'b', listOf('a', 'b'), { "x$it" })
+        expectMinMaxBy("b", "abc", listOf("abc", "b"), { it.length })
+    }
+
+    @Test
+    fun minMaxByEmpty() {
+        val empty = emptyList<Int>()
+        val selector = Int::toString
+        assertNull(empty.minByOrNull(selector))
+        assertNull(empty.maxByOrNull(selector))
+        assertFailsWith<NoSuchElementException> { empty.minBy(selector) }
+        assertFailsWith<NoSuchElementException> { empty.maxBy(selector) }
     }
 
     @Test fun minByOrNullEvaluateOnce() {

libraries/stdlib/test/collections/MinMaxOperations.kt

diff --git a/libraries/stdlib/test/collections/MinMaxOperations.kt b/libraries/stdlib/test/collections/MinMaxOperations.kt
new file mode 100644
index 0000000..875df43
--- /dev/null
+++ b/libraries/stdlib/test/collections/MinMaxOperations.kt
@@ -0,0 +1,95 @@
+/*
+ * 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.collections
+
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNull
+
+sealed class MinMaxOperations<C, T>(
+    val min: C.() -> T, val max: C.() -> T, val minOrNull: C.() -> T?, val maxOrNull: C.() -> T?,
+) {
+    object AInt : MinMaxOperations<IntArray, Int>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object ALong : MinMaxOperations<LongArray, Long>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object AShort : MinMaxOperations<ShortArray, Short>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object AByte : MinMaxOperations<ByteArray, Byte>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object AUInt : MinMaxOperations<UIntArray, UInt>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object AULong : MinMaxOperations<ULongArray, ULong>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object AUShort : MinMaxOperations<UShortArray, UShort>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object AUByte : MinMaxOperations<UByteArray, UByte>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object AFloat : MinMaxOperations<FloatArray, Float>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object ADouble : MinMaxOperations<DoubleArray, Double>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object AChar : MinMaxOperations<CharArray, Char>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    class ArrayT<T : Comparable<T>> : MinMaxOperations<Array<T>, T>({ min() }, { max() }, { minOrNull() }, { maxOrNull() }) {
+        companion object {
+            fun <T : Comparable<T>> expectMinMax(min: T, max: T, elements: Array<T>) {
+                ArrayT<T>().expectMinMax(min, max, elements)
+            }
+        }
+    }
+    class IterableT<T : Comparable<T>> : MinMaxOperations<Iterable<T>, T>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    class SequenceT<T : Comparable<T>> : MinMaxOperations<Sequence<T>, T>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+    object CharSeq : MinMaxOperations<CharSequence, Char>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+
+
+    fun expectMinMax(min: T, max: T, elements: C) {
+        assertEquals(min, elements.minOrNull())
+        assertEquals(max, elements.maxOrNull())
+        assertEquals(min, elements.min())
+        assertEquals(max, elements.max())
+    }
+
+    fun expectMinMaxEmpty(empty: C) {
+        assertNull(empty.minOrNull())
+        assertNull(empty.maxOrNull())
+        assertFailsWith<NoSuchElementException> { empty.min() }
+        assertFailsWith<NoSuchElementException> { empty.max() }
+    }
+}
+
+
+sealed class MinMaxOperationsWith<C, T>(
+    val minWith: C.(Comparator<T>) -> T, val maxWith: C.(Comparator<T>) -> T, val minWithOrNull: C.(Comparator<T>) -> T?, val maxWithOrNull: C.(Comparator<T>) -> T?,
+) {
+    object AInt : MinMaxOperationsWith<IntArray, Int>(IntArray::minWith, IntArray::maxWith, IntArray::minWithOrNull, IntArray::maxWithOrNull)
+    object ALong : MinMaxOperationsWith<LongArray, Long>(LongArray::minWith, LongArray::maxWith, LongArray::minWithOrNull, LongArray::maxWithOrNull)
+    object AShort : MinMaxOperationsWith<ShortArray, Short>(ShortArray::minWith, ShortArray::maxWith, ShortArray::minWithOrNull, ShortArray::maxWithOrNull)
+    object AByte : MinMaxOperationsWith<ByteArray, Byte>(ByteArray::minWith, ByteArray::maxWith, ByteArray::minWithOrNull, ByteArray::maxWithOrNull)
+    object AUInt : MinMaxOperationsWith<UIntArray, UInt>(UIntArray::minWith, UIntArray::maxWith, UIntArray::minWithOrNull, UIntArray::maxWithOrNull)
+    object AULong : MinMaxOperationsWith<ULongArray, ULong>(ULongArray::minWith, ULongArray::maxWith, ULongArray::minWithOrNull, ULongArray::maxWithOrNull)
+    object AUShort : MinMaxOperationsWith<UShortArray, UShort>(UShortArray::minWith, UShortArray::maxWith, UShortArray::minWithOrNull, UShortArray::maxWithOrNull)
+    object AUByte : MinMaxOperationsWith<UByteArray, UByte>(UByteArray::minWith, UByteArray::maxWith, UByteArray::minWithOrNull, UByteArray::maxWithOrNull)
+    object AFloat : MinMaxOperationsWith<FloatArray, Float>(FloatArray::minWith, FloatArray::maxWith, FloatArray::minWithOrNull, FloatArray::maxWithOrNull)
+    object ADouble : MinMaxOperationsWith<DoubleArray, Double>(DoubleArray::minWith, DoubleArray::maxWith, DoubleArray::minWithOrNull, DoubleArray::maxWithOrNull)
+    object AChar : MinMaxOperationsWith<CharArray, Char>(CharArray::minWith, CharArray::maxWith, CharArray::minWithOrNull, CharArray::maxWithOrNull)
+    class ArrayT<T> : MinMaxOperationsWith<Array<T>, T>(Array<T>::minWith, Array<T>::maxWith, Array<T>::minWithOrNull, Array<T>::maxWithOrNull) {
+        companion object {
+            fun <T> expectMinMaxWith(min: T, max: T, elements: Array<T>, comparator: Comparator<T>) {
+                ArrayT<T>().expectMinMaxWith(min, max, elements, comparator)
+            }
+        }
+    }
+//    class IterableT<T : Comparable<T>> : MinMaxOperationsWith<Iterable<T>, T>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+//    class SequenceT<T : Comparable<T>> : MinMaxOperationsWith<Sequence<T>, T>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+//    object CharSeq : MinMaxOperationsWith<CharSequence, Char>({ min() }, { max() }, { minOrNull() }, { maxOrNull() })
+
+
+    fun expectMinMaxWith(min: T, max: T, elements: C, comparator: Comparator<T>) {
+        assertEquals(min, elements.minWithOrNull(comparator))
+        assertEquals(max, elements.maxWithOrNull(comparator))
+        assertEquals(min, elements.minWith(comparator))
+        assertEquals(max, elements.maxWith(comparator))
+    }
+
+    fun expectMinMaxWithEmpty(empty: C, comparator: Comparator<T>) {
+        assertNull(empty.minWithOrNull(comparator))
+        assertNull(empty.maxWithOrNull(comparator))
+        assertFailsWith<NoSuchElementException> { empty.minWith(comparator) }
+        assertFailsWith<NoSuchElementException> { empty.maxWith(comparator) }
+    }
+}
+
+

libraries/stdlib/test/collections/SequenceTest.kt

diff --git a/libraries/stdlib/test/collections/SequenceTest.kt b/libraries/stdlib/test/collections/SequenceTest.kt
index 9ae24f5..4309204 100644
--- a/libraries/stdlib/test/collections/SequenceTest.kt
+++ b/libraries/stdlib/test/collections/SequenceTest.kt
@@ -5,6 +5,8 @@
 
 package test.collections
 
+import test.assertIsNegativeZero
+import test.assertIsPositiveZero
 import kotlin.random.Random
 import kotlin.test.*
 
@@ -633,6 +635,106 @@
         assertEquals(listOf('a', 'b', 'c'), chars)
     }
 
+    private fun <T : Comparable<T>> expectMinMax(min: T, max: T, elements: Sequence<T>) {
+        assertEquals(min, elements.minOrNull())
+        assertEquals(max, elements.maxOrNull())
+        assertEquals(min, elements.min())
+        assertEquals(max, elements.max())
+    }
+
+    @Test
+    fun minMax() {
+        expectMinMax(1, 1, sequenceOf(1))
+        expectMinMax(2, 3, sequenceOf(2, 3))
+        expectMinMax(2, 3, sequenceOf(3, 2))
+        expectMinMax(2000000000000, 3000000000000, sequenceOf(3000000000000, 2000000000000))
+        expectMinMax('a', 'b', sequenceOf('a', 'b'))
+        expectMinMax("a", "b", sequenceOf("a", "b"))
+    }
+
+    @Test
+    fun minMaxEmpty() {
+        val empty = emptySequence<Int>()
+        assertNull(empty.minOrNull())
+        assertNull(empty.maxOrNull())
+        assertFailsWith<NoSuchElementException> { empty.min() }
+        assertFailsWith<NoSuchElementException> { empty.max() }
+    }
+
+    @Test
+    fun minMaxFloatingPoint() {
+        val doubleZeroes = sequenceOf(0.0, -0.0)
+        val floatZeroes = sequenceOf(0.0F, -0.0F)
+        val doubleNaN = sequenceOf(0.0, Double.NaN)
+        val floatNaN = sequenceOf(0.0F, Float.NaN)
+
+        assertIsNegativeZero(doubleZeroes.shuffled().min())
+        assertIsNegativeZero(doubleZeroes.shuffled().minOrNull()!!)
+        assertIsNegativeZero(floatZeroes.shuffled().min().toDouble())
+        assertIsNegativeZero(floatZeroes.shuffled().minOrNull()!!.toDouble())
+        assertTrue(doubleNaN.shuffled().min().isNaN())
+        assertTrue(doubleNaN.shuffled().minOrNull()!!.isNaN())
+        assertTrue(floatNaN.shuffled().min().isNaN())
+        assertTrue(floatNaN.shuffled().minOrNull()!!.isNaN())
+
+        assertIsPositiveZero(doubleZeroes.shuffled().max())
+        assertIsPositiveZero(doubleZeroes.shuffled().maxOrNull()!!)
+        assertIsPositiveZero(floatZeroes.shuffled().max().toDouble())
+        assertIsPositiveZero(floatZeroes.shuffled().maxOrNull()!!.toDouble())
+        assertTrue(doubleNaN.shuffled().max().isNaN())
+        assertTrue(doubleNaN.shuffled().maxOrNull()!!.isNaN())
+        assertTrue(floatNaN.shuffled().max().isNaN())
+        assertTrue(floatNaN.shuffled().maxOrNull()!!.isNaN())
+    }
+
+    private fun <T> expectMinMaxWith(min: T, max: T, elements: Sequence<T>, comparator: Comparator<T>) {
+        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, sequenceOf(1), naturalOrder())
+        expectMinMaxWith("a", "B", sequenceOf("a", "B"), String.CASE_INSENSITIVE_ORDER)
+    }
+
+    @Test
+    fun minMaxWithEmpty() {
+        val empty = emptySequence<Int>()
+        assertNull(empty.minWithOrNull(naturalOrder()))
+        assertNull(empty.maxWithOrNull(naturalOrder()))
+        assertFailsWith<NoSuchElementException> { empty.minWith(naturalOrder()) }
+        assertFailsWith<NoSuchElementException> { empty.maxWith(naturalOrder()) }
+    }
+
+    private inline fun <T, K : Comparable<K>> expectMinMaxBy(min: T, max: T, elements: Sequence<T>, selector: (T) -> K) {
+        assertEquals(min, elements.minBy(selector))
+        assertEquals(min, elements.minByOrNull(selector))
+        assertEquals(max, elements.maxByOrNull(selector))
+        assertEquals(max, elements.maxByOrNull(selector))
+    }
+
+    @Test
+    fun minMaxBy() {
+        expectMinMaxBy(1, 1, sequenceOf(1), { it })
+        expectMinMaxBy(3, 2, sequenceOf(2, 3), { -it })
+        expectMinMaxBy('a', 'b', sequenceOf('a', 'b'), { "x$it" })
+        expectMinMaxBy("b", "abc", sequenceOf("abc", "b"), { it.length })
+    }
+    
+    @Test
+    fun minMaxByEmpty() {
+        val empty = emptySequence<Int>()
+        val selector = Int::toString
+        assertNull(empty.minByOrNull(selector))
+        assertNull(empty.maxByOrNull(selector))
+        assertFailsWith<NoSuchElementException> { empty.minBy(selector) }
+        assertFailsWith<NoSuchElementException> { empty.maxBy(selector) }
+    }
+
+
     @Test fun sorted() {
         sequenceOf(3, 7, 5).let {
             it.sorted().iterator().assertSorted { a, b -> a <= b }

libraries/stdlib/test/collections/UnsignedArraysTest.kt

diff --git a/libraries/stdlib/test/collections/UnsignedArraysTest.kt b/libraries/stdlib/test/collections/UnsignedArraysTest.kt
index a8f9231..fbc6b15 100644
--- a/libraries/stdlib/test/collections/UnsignedArraysTest.kt
+++ b/libraries/stdlib/test/collections/UnsignedArraysTest.kt
@@ -421,35 +421,38 @@
     }
 
     @Test
-    fun minOrNull() {
-        expect(null) { arrayOf<UByte>().minOrNull() }
-        expect(1u) { arrayOf<UShort>(1).minOrNull() }
-        expect(2u) { arrayOf<UInt>(2, 3).minOrNull() }
-        expect(2uL) { arrayOf<ULong>(3, 2).minOrNull() }
+    fun minMaxArrayOfUnsigned() = with(MinMaxOperations.ArrayT) {
+        expectMinMax(1u, 1u, arrayOf(1u))
+        expectMinMax(1u, UInt.MAX_VALUE, arrayOf(1u, UInt.MAX_VALUE))
+        expectMinMax(1uL, ULong.MAX_VALUE, arrayOf(1uL, ULong.MAX_VALUE))
     }
 
     @Test
-    fun minOrNullInUnsignedArrays() {
-        expect(null) { ubyteArrayOf().minOrNull() }
-        expect(1u) { ushortArrayOf(1).minOrNull() }
-        expect(2u) { uintArrayOf(2, 3).minOrNull() }
-        expect(2uL) { ulongArrayOf(3, 2).minOrNull() }
+    fun minMaxUIntArray() = with(MinMaxOperations.AUInt) {
+        expectMinMaxEmpty(uintArrayOf())
+        expectMinMax(1, 1, uintArrayOf(1))
+        expectMinMax(1, UInt.MAX_VALUE, uintArrayOf(1, UInt.MAX_VALUE))
     }
 
     @Test
-    fun maxOrNull() {
-        expect(null) { arrayOf<UByte>().maxOrNull() }
-        expect(1u) { arrayOf<UShort>(1).maxOrNull() }
-        expect(3u) { arrayOf<UInt>(2, 3).maxOrNull() }
-        expect(3uL) { arrayOf<ULong>(3, 2).maxOrNull() }
+    fun minMaxULongArray() = with(MinMaxOperations.AULong) {
+        expectMinMaxEmpty(ulongArrayOf())
+        expectMinMax(1, 1, ulongArrayOf(1))
+        expectMinMax(1, ULong.MAX_VALUE, ulongArrayOf(1, ULong.MAX_VALUE))
     }
 
     @Test
-    fun maxOrNullInUnsignedArrays() {
-        expect(null) { ubyteArrayOf().maxOrNull() }
-        expect(1u) { ushortArrayOf(1).maxOrNull() }
-        expect(3u) { uintArrayOf(2, 3).maxOrNull() }
-        expect(3uL) { ulongArrayOf(3, 2).maxOrNull() }
+    fun minMaxUShortArray() = with(MinMaxOperations.AUShort) {
+        expectMinMaxEmpty(ushortArrayOf())
+        expectMinMax(1, 1, ushortArrayOf(1))
+        expectMinMax(1, 2, ushortArrayOf(1, 2))
+    }
+
+    @Test
+    fun minMaxUByteArray() = with(MinMaxOperations.AUByte) {
+        expectMinMaxEmpty(ubyteArrayOf())
+        expectMinMax(1, 1, ubyteArrayOf(1))
+        expectMinMax(1, 2, ubyteArrayOf(1, 2))
     }
 
     @Test