JS: Provide MIN_VALUE and MAX_VALUE member constants for Double and Float companion objects.

JVM: Make MIN_VALUE and MAX_VALUE not an extension but member constant properties of Double and Float companion objects.

libraries/stdlib/src/kotlin/jvm/BuiltinExtensions.kt

@@ -1,35 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package kotlin.jvm
-
-
-/**
- * A constant holding the smallest positive nonzero value of type `Double`, 2^-1074.
- */
-public val Double.Companion.MIN_VALUE: Double get() = java.lang.Double.MIN_VALUE
-/**
- * A constant holding the largest positive finite value of type `Double`, (2-2^-52)*2^1023.
- */
-public val Double.Companion.MAX_VALUE: Double get() = java.lang.Double.MAX_VALUE
-
-/**
- * A constant holding the smallest positive nonzero value of type `Float`, 2^-149.
- */
-public val Float.Companion.MIN_VALUE: Float get() = java.lang.Float.MIN_VALUE
-/**
- * * A constant holding the largest positive finite value of type `Float`, (2-2^-23)*2^127.
- */
-public val Float.Companion.MAX_VALUE: Float get() = java.lang.Float.MAX_VALUE

libraries/stdlib/test/numbers/NumbersTest.kt

@@ -12,35 +12,54 @@ class NumbersTest {
 
         // overflow behavior
         // doesn't hold for JS Number
-        // assertEquals(Int.MIN_VALUE, Int.MAX_VALUE + 1)
+        // expect(Int.MIN_VALUE) { Int.MAX_VALUE + 1 }
+        // expect(Int.MAX_VALUE) { Int.MIN_VALUE - 1 }
     }
 
     test fun longMinMaxValues() {
         assertTrue(Long.MIN_VALUE < 0)
         assertTrue(Long.MAX_VALUE > 0)
         // overflow behavior
-        assertEquals(Long.MIN_VALUE, Long.MAX_VALUE + 1)
-        assertEquals(Long.MAX_VALUE, Long.MIN_VALUE - 1)
+        expect(Long.MIN_VALUE) { Long.MAX_VALUE + 1 }
+        expect(Long.MAX_VALUE) { Long.MIN_VALUE - 1 }
     }
 
     test fun shortMinMaxValues() {
         assertTrue(Short.MIN_VALUE < 0)
         assertTrue(Short.MAX_VALUE > 0)
         // overflow behavior
-        assertEquals(Short.MIN_VALUE, (Short.MAX_VALUE + 1).toShort())
-        assertEquals(Short.MAX_VALUE, (Short.MIN_VALUE - 1).toShort())
+        expect(Short.MIN_VALUE) { (Short.MAX_VALUE + 1).toShort() }
+        expect(Short.MAX_VALUE) { (Short.MIN_VALUE - 1).toShort() }
     }
 
     test fun byteMinMaxValues() {
         assertTrue(Byte.MIN_VALUE < 0)
         assertTrue(Byte.MAX_VALUE > 0)
         // overflow behavior
-        assertEquals(Byte.MIN_VALUE, (Byte.MAX_VALUE + 1).toByte())
-        assertEquals(Byte.MAX_VALUE, (Byte.MIN_VALUE - 1).toByte())
+        expect(Byte.MIN_VALUE) { (Byte.MAX_VALUE + 1).toByte() }
+        expect(Byte.MAX_VALUE) { (Byte.MIN_VALUE - 1).toByte() }
     }
 
+    test fun doubleMinMaxValues() {
+        assertTrue(Double.MIN_VALUE > 0)
+        assertTrue(Double.MAX_VALUE > 0)
+        // overflow behavior
+        expect(Double.POSITIVE_INFINITY) { Double.MAX_VALUE * 2 }
+        expect(Double.NEGATIVE_INFINITY) {-Double.MAX_VALUE * 2 }
+        expect(0.0) { Double.MIN_VALUE / 2 }
+    }
+
+    test fun floatMinMaxValues() {
+        assertTrue(Float.MIN_VALUE > 0)
+        assertTrue(Float.MAX_VALUE > 0)
+        // overflow behavior
+        expect(Float.POSITIVE_INFINITY) { Float.MAX_VALUE * 2 }
+        expect(Float.NEGATIVE_INFINITY) { -Float.MAX_VALUE * 2 }
+        expect(0.0F) { Float.MIN_VALUE / 2.0F }
+    }
+    
     test fun doubleProperties() {
-        for (value in listOf(1.0, 0.0))
+        for (value in listOf(1.0, 0.0, Double.MIN_VALUE, Double.MAX_VALUE))
             doTestNumber(value)
         for (value in listOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY))
             doTestNumber(value, isInfinite = true)
@@ -48,7 +67,7 @@ class NumbersTest {
     }
 
     test fun floatProperties() {
-        for (value in listOf(1.0F, 0.0F))
+        for (value in listOf(1.0F, 0.0F, Float.MAX_VALUE, Float.MIN_VALUE))
             doTestNumber(value)
         for (value in listOf(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY))
             doTestNumber(value, isInfinite = true)