Add vararg overloads for maxOf/minOf functions #KT-33906

libraries/stdlib/test/OrderingTest.kt

@@ -20,6 +20,7 @@ class OrderingTest {
     val v1 = Item("wine", 9)
     val v2 = Item("beer", 10)
     val v3 = Item("apple", 20)
+    val v4 = Item("grape", 22)
 
     @Test
     fun compareByCompareTo() {
@@ -154,44 +155,56 @@ class OrderingTest {
     fun maxOf() {
         assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE))
         assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE, 0))
+        assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE, 0, -1))
 
         assertEquals(Long.MAX_VALUE, maxOf(Long.MAX_VALUE, Long.MIN_VALUE))
         assertEquals(Long.MAX_VALUE, maxOf(Long.MAX_VALUE, Long.MIN_VALUE, 0))
+        assertEquals(Long.MAX_VALUE, maxOf(Long.MAX_VALUE, Long.MIN_VALUE, 0, -1))
 
         assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY))
         assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE))
+        assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE))
         assertEquals(0.0, maxOf(0.0, -0.0))
         assertEquals(0.0, maxOf(-0.0, 0.0))
+        assertEquals(0.0, maxOf(-0.0, 0.0, 0.0, -0.0))
     }
 
     @Test
     fun maxOfWith() {
         assertEquals(v1, maxOf(v1, v2, compareBy { it.name }))
         assertEquals(v1, maxOf(v3, v2, v1, compareBy { it.name }))
+        assertEquals(v1, maxOf(v4, v3, v2, v1, comparator = compareBy { it.name }))
         assertEquals(v2, maxOf(v1, v2, compareBy { it.rating }))
         assertEquals(v3, maxOf(v1, v2, v3, compareBy { it.rating }))
+        assertEquals(v4, maxOf(v4, v1, v2, v3, comparator = compareBy { it.rating }))
     }
 
     @Test
     fun minOf() {
         assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE))
         assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE, 0))
+        assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE, 0, -1))
 
         assertEquals(Long.MIN_VALUE, minOf(Long.MAX_VALUE, Long.MIN_VALUE))
         assertEquals(Long.MIN_VALUE, minOf(Long.MAX_VALUE, Long.MIN_VALUE, 0))
+        assertEquals(Long.MIN_VALUE, minOf(Long.MAX_VALUE, Long.MIN_VALUE, 0, -1))
 
         assertEquals(Double.NEGATIVE_INFINITY, minOf(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY))
         assertEquals(Double.MIN_VALUE, minOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE))
+        assertEquals(Double.NEGATIVE_INFINITY, minOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE))
         assertEquals(-0.0, minOf(0.0, -0.0))
         assertEquals(-0.0, minOf(-0.0, 0.0))
+        assertEquals(-0.0, minOf(-0.0, 0.0, 0.0, -0.0))
     }
 
     @Test
     fun minOfWith() {
         assertEquals(v2, minOf(v1, v2, compareBy { it.name }))
         assertEquals(v3, minOf(v3, v2, v1, compareBy { it.name }))
+        assertEquals(v3, minOf(v4, v2, v3, v1, comparator = compareBy { it.name }))
         assertEquals(v1, minOf(v1, v2, compareBy { it.rating }))
         assertEquals(v1, minOf(v1, v2, v3, compareBy { it.rating }))
+        assertEquals(v1, minOf(v4, v1, v2, v3, comparator = compareBy { it.rating }))
     }
 
 }

libraries/stdlib/test/numbers/NaNPropagationTest.kt

@@ -58,12 +58,30 @@ class NaNPropagationTest {
         propagateOf3(::minOf, ::minOf, "minOf")
     }
 
+    @Test
+    fun minOfVararg() {
+        propagateOf3(
+            { a, b, c -> minOf(a, *doubleArrayOf(b, c)) },
+            { a, b, c -> minOf(a, *floatArrayOf(b, c)) },
+            "minOf(a, vararg other)"
+        )
+    }
+
     @Test
     fun maxOf() {
         propagateOf2(::maxOf, ::maxOf, "maxOf")
         propagateOf3(::maxOf, ::maxOf, "maxOf")
     }
 
+    @Test
+    fun maxOfVararg() {
+        propagateOf3(
+            { a, b, c -> maxOf(a, *doubleArrayOf(b, c)) },
+            { a, b, c -> maxOf(a, *floatArrayOf(b, c)) },
+            "maxOf(a, vararg other)"
+        )
+    }
+
     @Test
     fun arrayMin() {
         propagateOf2(

libraries/stdlib/test/unsigned/UComparisonsTest.kt

@@ -26,6 +26,14 @@ class UComparisonsTest {
         expect(42312uL) { minOf(42312uL, 42312uL, 42312uL) }
     }
 
+    @Test
+    fun minOf_vararg() {
+        expect(1.toUByte()) { minOf(2.toUByte(), 1.toUByte(), 3.toUByte(), 2.toUByte(), 10.toUByte()) }
+        expect(55.toUShort()) { minOf(58.toUShort(), 32768.toUShort(), 55.toUShort(), 2423.toUShort()) }
+        expect(UInt.MIN_VALUE) { minOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u, 1000u, (-1).toUInt(), Int.MAX_VALUE.toUInt()) }
+        expect(42312uL) { minOf(42312uL, 42312uL, 42312uL, 42312uL) }
+    }
+
     @Test
     fun maxOf_2() {
         expect(2.toUByte()) { maxOf(2.toUByte(), 1.toUByte()) }
@@ -41,4 +49,12 @@ class UComparisonsTest {
         expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u) }
         expect(42312uL) { maxOf(42312uL, 42312uL, 42312uL) }
     }
+
+    @Test
+    fun maxOf_vararg() {
+        expect(10.toUByte()) { maxOf(2.toUByte(), 1.toUByte(), 3.toUByte(), 2.toUByte(), 10.toUByte()) }
+        expect(32768.toUShort()) { maxOf(58.toUShort(), 32768.toUShort(), 55.toUShort(), 2423.toUShort()) }
+        expect(UInt.MAX_VALUE) { maxOf(UInt.MIN_VALUE, UInt.MAX_VALUE, 0u, 1000u, (-1).toUInt(), Int.MAX_VALUE.toUInt()) }
+        expect(42312uL) { maxOf(42312uL, 42312uL, 42312uL, 42312uL) }
+    }
 }