Introduce minOrNull and maxOrNull extension functions #KT-39064
This commit is contained in:
Abduqodiri Qurbonzoda
@@ -348,46 +348,46 @@ class ArraysTest {
|
||||
|
||||
|
||||
|
||||
@Test fun min() {
|
||||
expect(null, { arrayOf<Int>().min() })
|
||||
expect(1, { arrayOf(1).min() })
|
||||
expect(2, { arrayOf(2, 3).min() })
|
||||
expect(2000000000000, { arrayOf(3000000000000, 2000000000000).min() })
|
||||
expect('a', { arrayOf('a', 'b').min() })
|
||||
expect("a", { arrayOf("a", "b").min() })
|
||||
@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 minInPrimitiveArrays() {
|
||||
expect(null, { intArrayOf().min() })
|
||||
expect(1, { intArrayOf(1).min() })
|
||||
expect(2, { intArrayOf(2, 3).min() })
|
||||
expect(2000000000000, { longArrayOf(3000000000000, 2000000000000).min() })
|
||||
expect(1, { byteArrayOf(1, 3, 2).min() })
|
||||
expect(2, { shortArrayOf(3, 2).min() })
|
||||
expect(2.0F, { floatArrayOf(3.0F, 2.0F).min() })
|
||||
expect(2.0, { doubleArrayOf(2.0, 3.0).min() })
|
||||
expect('a', { charArrayOf('a', 'b').min() })
|
||||
@Test fun minOrNullInPrimitiveArrays() {
|
||||
expect(null, { intArrayOf().minOrNull() })
|
||||
expect(1, { intArrayOf(1).minOrNull() })
|
||||
expect(2, { intArrayOf(2, 3).minOrNull() })
|
||||
expect(2000000000000, { longArrayOf(3000000000000, 2000000000000).minOrNull() })
|
||||
expect(1, { byteArrayOf(1, 3, 2).minOrNull() })
|
||||
expect(2, { shortArrayOf(3, 2).minOrNull() })
|
||||
expect(2.0F, { floatArrayOf(3.0F, 2.0F).minOrNull() })
|
||||
expect(2.0, { doubleArrayOf(2.0, 3.0).minOrNull() })
|
||||
expect('a', { charArrayOf('a', 'b').minOrNull() })
|
||||
}
|
||||
|
||||
@Test fun max() {
|
||||
expect(null, { arrayOf<Int>().max() })
|
||||
expect(1, { arrayOf(1).max() })
|
||||
expect(3, { arrayOf(2, 3).max() })
|
||||
expect(3000000000000, { arrayOf(3000000000000, 2000000000000).max() })
|
||||
expect('b', { arrayOf('a', 'b').max() })
|
||||
expect("b", { arrayOf("a", "b").max() })
|
||||
@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 maxInPrimitiveArrays() {
|
||||
expect(null, { intArrayOf().max() })
|
||||
expect(1, { intArrayOf(1).max() })
|
||||
expect(3, { intArrayOf(2, 3).max() })
|
||||
expect(3000000000000, { longArrayOf(3000000000000, 2000000000000).max() })
|
||||
expect(3, { byteArrayOf(1, 3, 2).max() })
|
||||
expect(3, { shortArrayOf(3, 2).max() })
|
||||
expect(3.0F, { floatArrayOf(3.0F, 2.0F).max() })
|
||||
expect(3.0, { doubleArrayOf(2.0, 3.0).max() })
|
||||
expect('b', { charArrayOf('a', 'b').max() })
|
||||
@Test fun maxOrNullInPrimitiveArrays() {
|
||||
expect(null, { intArrayOf().maxOrNull() })
|
||||
expect(1, { intArrayOf(1).maxOrNull() })
|
||||
expect(3, { intArrayOf(2, 3).maxOrNull() })
|
||||
expect(3000000000000, { longArrayOf(3000000000000, 2000000000000).maxOrNull() })
|
||||
expect(3, { byteArrayOf(1, 3, 2).maxOrNull() })
|
||||
expect(3, { shortArrayOf(3, 2).maxOrNull() })
|
||||
expect(3.0F, { floatArrayOf(3.0F, 2.0F).maxOrNull() })
|
||||
expect(3.0, { doubleArrayOf(2.0, 3.0).maxOrNull() })
|
||||
expect('b', { charArrayOf('a', 'b').maxOrNull() })
|
||||
}
|
||||
|
||||
@Test fun minWith() {
|
||||
|
||||
@@ -823,32 +823,32 @@ class CollectionTest {
|
||||
assertTrue(hashSetOf(45, 14, 13).toIterable().contains(14))
|
||||
}
|
||||
|
||||
@Test fun min() {
|
||||
expect(null, { listOf<Int>().min() })
|
||||
expect(1, { listOf(1).min() })
|
||||
expect(2, { listOf(2, 3).min() })
|
||||
expect(2000000000000, { listOf(3000000000000, 2000000000000).min() })
|
||||
expect('a', { listOf('a', 'b').min() })
|
||||
expect("a", { listOf("a", "b").min() })
|
||||
expect(null, { listOf<Int>().asSequence().min() })
|
||||
expect(2, { listOf(2, 3).asSequence().min() })
|
||||
@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().min()!!)
|
||||
assertIsNegativeZero(listOf(0.0F, -0.0F).shuffled().min()!!.toDouble())
|
||||
assertIsNegativeZero(listOf(0.0, -0.0).shuffled().minOrNull()!!)
|
||||
assertIsNegativeZero(listOf(0.0F, -0.0F).shuffled().minOrNull()!!.toDouble())
|
||||
}
|
||||
|
||||
@Test fun max() {
|
||||
expect(null, { listOf<Int>().max() })
|
||||
expect(1, { listOf(1).max() })
|
||||
expect(3, { listOf(2, 3).max() })
|
||||
expect(3000000000000, { listOf(3000000000000, 2000000000000).max() })
|
||||
expect('b', { listOf('a', 'b').max() })
|
||||
expect("b", { listOf("a", "b").max() })
|
||||
expect(null, { listOf<Int>().asSequence().max() })
|
||||
expect(3, { listOf(2, 3).asSequence().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().max()!!)
|
||||
assertIsPositiveZero(listOf(0.0F, -0.0F).shuffled().max()!!.toDouble())
|
||||
assertIsPositiveZero(listOf(0.0, -0.0).shuffled().maxOrNull()!!)
|
||||
assertIsPositiveZero(listOf(0.0F, -0.0F).shuffled().maxOrNull()!!.toDouble())
|
||||
}
|
||||
|
||||
@Test fun minWith() {
|
||||
|
||||
@@ -394,14 +394,14 @@ abstract class IterableTests<T : Iterable<String>>(val createFrom: (Array<out St
|
||||
}
|
||||
|
||||
@Test
|
||||
fun max() {
|
||||
expect("foo") { data.max() }
|
||||
fun maxOrNull() {
|
||||
expect("foo") { data.maxOrNull() }
|
||||
expect("bar") { data.maxBy { it.last() } }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun min() {
|
||||
expect("bar") { data.min() }
|
||||
fun minOrNull() {
|
||||
expect("bar") { data.minOrNull() }
|
||||
expect("foo") { data.minBy { it.last() } }
|
||||
}
|
||||
|
||||
|
||||
@@ -419,35 +419,35 @@ class UnsignedArraysTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun min() {
|
||||
expect(null) { arrayOf<UByte>().min() }
|
||||
expect(1u) { arrayOf<UShort>(1).min() }
|
||||
expect(2u) { arrayOf<UInt>(2, 3).min() }
|
||||
expect(2uL) { arrayOf<ULong>(3, 2).min() }
|
||||
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() }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun minInUnsignedArrays() {
|
||||
expect(null) { ubyteArrayOf().min() }
|
||||
expect(1u) { ushortArrayOf(1).min() }
|
||||
expect(2u) { uintArrayOf(2, 3).min() }
|
||||
expect(2uL) { ulongArrayOf(3, 2).min() }
|
||||
fun minOrNullInUnsignedArrays() {
|
||||
expect(null) { ubyteArrayOf().minOrNull() }
|
||||
expect(1u) { ushortArrayOf(1).minOrNull() }
|
||||
expect(2u) { uintArrayOf(2, 3).minOrNull() }
|
||||
expect(2uL) { ulongArrayOf(3, 2).minOrNull() }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun max() {
|
||||
expect(null) { arrayOf<UByte>().max() }
|
||||
expect(1u) { arrayOf<UShort>(1).max() }
|
||||
expect(3u) { arrayOf<UInt>(2, 3).max() }
|
||||
expect(3uL) { arrayOf<ULong>(3, 2).max() }
|
||||
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() }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun maxInUnsignedArrays() {
|
||||
expect(null) { ubyteArrayOf().max() }
|
||||
expect(1u) { ushortArrayOf(1).max() }
|
||||
expect(3u) { uintArrayOf(2, 3).max() }
|
||||
expect(3uL) { ulongArrayOf(3, 2).max() }
|
||||
fun maxOrNullInUnsignedArrays() {
|
||||
expect(null) { ubyteArrayOf().maxOrNull() }
|
||||
expect(1u) { ushortArrayOf(1).maxOrNull() }
|
||||
expect(3u) { uintArrayOf(2, 3).maxOrNull() }
|
||||
expect(3uL) { ulongArrayOf(3, 2).maxOrNull() }
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
Reference in New Issue
Block a user