diff --git a/libraries/stdlib/common/test/testUtils.kt b/libraries/stdlib/common/test/testUtils.kt index ba18a0bc59d..8c00ebac2d3 100644 --- a/libraries/stdlib/common/test/testUtils.kt +++ b/libraries/stdlib/common/test/testUtils.kt @@ -18,6 +18,8 @@ package test public expect fun assertTypeEquals(expected: Any?, actual: Any?) +public expect fun randomInt(limit: Int): Int + internal expect fun String.removeLeadingPlusOnJava6(): String internal expect fun doubleTotalOrderEquals(a: Double?, b: Double?): Boolean diff --git a/libraries/stdlib/js/test/core/testUtils.kt b/libraries/stdlib/js/test/core/testUtils.kt index 90c854e154f..a96f5ec9cdb 100644 --- a/libraries/stdlib/js/test/core/testUtils.kt +++ b/libraries/stdlib/js/test/core/testUtils.kt @@ -22,6 +22,9 @@ public fun assertTypeEquals(expected: Any?, actual: Any?) { assertEquals(expected?.let { it::class.js }, actual?.let { it::class.js }) } +@Suppress("DEPRECATION") +public fun randomInt(limit: Int): Int = (kotlin.js.Math.random() * limit).toInt() + @Suppress("NOTHING_TO_INLINE") internal inline fun String.removeLeadingPlusOnJava6(): String = this internal fun doubleTotalOrderEquals(a: Double?, b: Double?) = a == b || (a != a && b != b) diff --git a/libraries/stdlib/test/collections/MutableCollectionsJVMTest.kt b/libraries/stdlib/test/collections/MutableCollectionsJVMTest.kt new file mode 100644 index 00000000000..43d70b0f2f9 --- /dev/null +++ b/libraries/stdlib/test/collections/MutableCollectionsJVMTest.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +@file:JvmVersion +package test.collections + +import kotlin.test.* + + +class MutableCollectionJVMTest { + + @Test fun shuffledRnd() { + val rnd1 = java.util.Random(42L) + val rnd2 = java.util.Random(42L) + + val list = MutableList(100) { it } + val shuffled1 = list.shuffled(rnd1) + val shuffled2 = list.shuffled(rnd2) + + + assertNotEquals(list, shuffled1) + assertEquals(list.toSet(), shuffled1.toSet()) + assertEquals(list.size, shuffled1.distinct().size) + + assertEquals(shuffled1, shuffled2) + } +} \ No newline at end of file diff --git a/libraries/stdlib/test/collections/MutableCollectionsTest.kt b/libraries/stdlib/test/collections/MutableCollectionsTest.kt index cd2bb6ffeed..c7a97bbc634 100644 --- a/libraries/stdlib/test/collections/MutableCollectionsTest.kt +++ b/libraries/stdlib/test/collections/MutableCollectionsTest.kt @@ -109,20 +109,4 @@ class MutableCollectionTest { assertEquals(list.size, shuffled.distinct().size) } - @JvmVersion - @Test fun shuffledRnd() { - val rnd1 = java.util.Random(42L) - val rnd2 = java.util.Random(42L) - - val list = MutableList(100) { it } - val shuffled1 = list.shuffled(rnd1) - val shuffled2 = list.shuffled(rnd2) - - - assertNotEquals(list, shuffled1) - assertEquals(list.toSet(), shuffled1.toSet()) - assertEquals(list.size, shuffled1.distinct().size) - - assertEquals(shuffled1, shuffled2) - } } diff --git a/libraries/stdlib/test/properties/delegation/lazy/LazyValuesJVMTest.kt b/libraries/stdlib/test/properties/delegation/lazy/LazyValuesJVMTest.kt new file mode 100644 index 00000000000..548d0950779 --- /dev/null +++ b/libraries/stdlib/test/properties/delegation/lazy/LazyValuesJVMTest.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +@file:JvmVersion +package test.properties.delegation.lazy + +import kotlin.test.* +import kotlin.jvm.Volatile + +class SynchronizedLazyValTest { + @Volatile + var result = 0 + val a by lazy(this) { + ++result + } + + @Test fun doTest() { + synchronized(this) { + kotlin.concurrent.thread { a } // not available in js + result = 1 + a + } + assertTrue(a == 2, "fail: initializer should be invoked only once") + assertTrue(result == 2, "fail result should be incremented after test") + } +} \ No newline at end of file diff --git a/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt b/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt index b44f03112b9..060f1bad0a7 100644 --- a/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt +++ b/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt @@ -1,6 +1,5 @@ package test.properties.delegation.lazy -import kotlin.properties.* import kotlin.test.* class LazyValTest { @@ -15,24 +14,6 @@ class LazyValTest { } } -@JvmVersion -class SynchronizedLazyValTest { - @Volatile var result = 0 - val a by lazy(this) { - ++result - } - - @Test fun doTest() { - synchronized(this) { - kotlin.concurrent.thread { a } // not available in js - result = 1 - a - } - assertTrue(a == 2, "fail: initializer should be invoked only once") - assertTrue(result == 2, "fail result should be incremented after test") - } -} - class UnsafeLazyValTest { var result = 0 val a by lazy(LazyThreadSafetyMode.NONE) { diff --git a/libraries/stdlib/test/testUtilsJVM.kt b/libraries/stdlib/test/testUtilsJVM.kt index 8b02e61ead3..2190d62e34f 100644 --- a/libraries/stdlib/test/testUtilsJVM.kt +++ b/libraries/stdlib/test/testUtilsJVM.kt @@ -23,6 +23,8 @@ public fun assertTypeEquals(expected: Any?, actual: Any?) { assertEquals(expected?.javaClass, actual?.javaClass) } +@JvmVersion +public fun randomInt(limit: Int): Int = (Math.random() * limit).toInt() @kotlin.jvm.JvmVersion private val isJava6 = System.getProperty("java.version").startsWith("1.6.") diff --git a/libraries/stdlib/test/text/StringNumberConversionJVMTest.kt b/libraries/stdlib/test/text/StringNumberConversionJVMTest.kt new file mode 100644 index 00000000000..ac72e991e21 --- /dev/null +++ b/libraries/stdlib/test/text/StringNumberConversionJVMTest.kt @@ -0,0 +1,153 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +@file:JvmVersion +package test.text + +import test.* +import kotlin.test.* + +class StringNumberConversionJVMTest { + + @JvmVersion + @Test fun toIntArabicDigits() { + compareConversion({ it.toInt() }, { it.toIntOrNull() }) { + assertProduces("٢٣١٩٦٠", 231960) + } + } + + @JvmVersion + @Test fun toLongArabicDigits() { + compareConversion({ it.toLong() }, { it.toLongOrNull() }) { + assertProduces("٢٣١٩٦٠٧٧٨٤٥٩", 231960778459) + } + } + + @kotlin.jvm.JvmVersion + @Test fun toFloat() { + compareConversion(String::toFloat, String::toFloatOrNull) { + assertProduces("77.0", 77.0f) + assertProduces("-1e39", Float.NEGATIVE_INFINITY) + assertProduces("1000000000000000000000000000000000000000", Float.POSITIVE_INFINITY) + assertFailsOrNull("dark side") + assertFailsOrNull("") + assertFailsOrNull(" ") + } + } + + + @kotlin.jvm.JvmVersion + @Test fun toHexDouble() { + compareConversion(String::toDouble, String::toDoubleOrNull, ::doubleTotalOrderEquals) { + assertProduces("0x77p1", (0x77 shl 1).toDouble()) + assertProduces("0x.77P8", 0x77.toDouble()) + + assertFailsOrNull("0x77e1") + } + } + + + @kotlin.jvm.JvmVersion + @Test fun byteToStringWithRadix() { + assertEquals("7a", 0x7a.toByte().toString(16)) + assertEquals("-80", Byte.MIN_VALUE.toString(radix = 16)) + assertEquals("3v", Byte.MAX_VALUE.toString(radix = 32)) + assertEquals("-40", Byte.MIN_VALUE.toString(radix = 32)) + + assertFailsWith("Expected to fail with radix 37") { 37.toByte().toString(radix = 37) } + assertFailsWith("Expected to fail with radix 1") { 1.toByte().toString(radix = 1) } + } + + @kotlin.jvm.JvmVersion + @Test fun shortToStringWithRadix() { + assertEquals("7FFF", 0x7FFF.toShort().toString(radix = 16).toUpperCase()) + assertEquals("-8000", (-0x8000).toShort().toString(radix = 16)) + assertEquals("-sfs", (-29180).toShort().toString(radix = 32)) + + assertFailsWith("Expected to fail with radix 37") { 37.toShort().toString(radix = 37) } + assertFailsWith("Expected to fail with radix 1") { 1.toShort().toString(radix = 1) } + } + + @kotlin.jvm.JvmVersion + @Test fun intToStringWithRadix() { + assertEquals("-ff", (-255).toString(radix = 16)) + assertEquals("1100110", 102.toString(radix = 2)) + assertEquals("kona", 411787.toString(radix = 27)) + assertFailsWith("Expected to fail with radix 37") { 37.toString(radix = 37) } + assertFailsWith("Expected to fail with radix 1") { 1.toString(radix = 1) } + + } + + @kotlin.jvm.JvmVersion + @Test fun longToStringWithRadix() { + assertEquals("7f11223344556677", 0x7F11223344556677.toString(radix = 16)) + assertEquals("hazelnut", 1356099454469L.toString(radix = 36)) + assertEquals("-8000000000000000", Long.MIN_VALUE.toString(radix = 16)) + + assertFailsWith("Expected to fail with radix 37") { 37L.toString(radix = 37) } + assertFailsWith("Expected to fail with radix 1") { 1L.toString(radix = 1) } + } + + @kotlin.jvm.JvmVersion + @Test fun toBigInteger() { + compareConversion(String::toBigInteger, String::toBigIntegerOrNull) { + assertProduces("0", java.math.BigInteger.ZERO) + assertProduces("1", java.math.BigInteger.ONE) + assertProduces("-1", java.math.BigInteger.ONE.negate()) + assertProduces("100000000000000000000", java.math.BigInteger("100000000000000000000")) + assertFailsOrNull("") + assertFailsOrNull("-") + assertFailsOrNull("a") + assertFailsOrNull("-x") + assertFailsOrNull("1000 000") + } + + compareConversionWithRadix(String::toBigInteger, String::toBigIntegerOrNull) { + assertProduces(16, "ABCDEF90ABCDEF9012345678", java.math.BigInteger("ABCDEF90ABCDEF9012345678", 16)) + assertProduces(36, "HazelnutHazelnut", java.math.BigInteger.valueOf(1356099454469L).let { it.multiply(java.math.BigInteger.valueOf(36).pow(8)).add(it) }) + + assertFailsOrNull(16, "EFG") + assertFailsOrNull(10, "-1A") + assertFailsOrNull(2, "-") + assertFailsOrNull(3, "") + + assertFailsWith("Expected to fail with radix 37") { "37".toBigInteger(radix = 37) } + assertFailsWith("Expected to fail with radix 1") { "1".toBigIntegerOrNull(radix = 1) } + } + } + + @kotlin.jvm.JvmVersion + @Test fun toBigDecimal() { + fun bd(value: String) = java.math.BigDecimal(value) + compareConversion(String::toBigDecimal, String::toBigDecimalOrNull) { + + assertProduces("-77", bd("-77")) + assertProduces("-77.0", bd("-77.0")) + assertProduces("77.", bd("77")) + assertProduces("123456789012345678901234567890.123456789", bd("123456789012345678901234567890.123456789")) + assertProduces("-1.77", bd("-1.77")) + assertProduces("+.77", bd("0.77")) + assertProduces("7.7e1", bd("77")) + assertProduces("+770e-1", bd("77.0")) + + assertFailsOrNull("7..7") + assertFailsOrNull("\t-77 \n") + assertFailsOrNull("007 not a number") + assertFailsOrNull("") + assertFailsOrNull(" ") + } + + var mc = java.math.MathContext(3, java.math.RoundingMode.UP) + compareConversion( { it.toBigDecimal(mc) }, { it.toBigDecimalOrNull(mc) }) { + assertProduces("1.991", bd("2.00")) + + mc = java.math.MathContext(1, java.math.RoundingMode.UNNECESSARY) + + assertFailsWith { "2.991".toBigDecimal(mc) } + assertFailsWith { "2.991".toBigDecimalOrNull(mc) } + } + } + +} \ No newline at end of file diff --git a/libraries/stdlib/test/text/StringNumberConversionTest.kt b/libraries/stdlib/test/text/StringNumberConversionTest.kt index 2a5ed755bc6..48d41f3718a 100644 --- a/libraries/stdlib/test/text/StringNumberConversionTest.kt +++ b/libraries/stdlib/test/text/StringNumberConversionTest.kt @@ -88,12 +88,6 @@ class StringNumberConversionTest { assertFailsWith("Expected to fail with radix 37") { "37".toIntOrNull(radix = 37) } } - @JvmVersion - @Test fun toIntArabicDigits() { - compareConversion({ it.toInt() }, { it.toIntOrNull() }) { - assertProduces("٢٣١٩٦٠", 231960) - } - } @Test fun toLong() { compareConversion({it.toLong()}, {it.toLongOrNull()}) { @@ -133,24 +127,6 @@ class StringNumberConversionTest { assertFailsWith("Expected to fail with radix 1") { "1".toLongOrNull(radix = 1) } } - @JvmVersion - @Test fun toLongArabicDigits() { - compareConversion({ it.toLong() }, { it.toLongOrNull() }) { - assertProduces("٢٣١٩٦٠٧٧٨٤٥٩", 231960778459) - } - } - - @kotlin.jvm.JvmVersion - @Test fun toFloat() { - compareConversion(String::toFloat, String::toFloatOrNull) { - assertProduces("77.0", 77.0f) - assertProduces("-1e39", Float.NEGATIVE_INFINITY) - assertProduces("1000000000000000000000000000000000000000", Float.POSITIVE_INFINITY) - assertFailsOrNull("dark side") - assertFailsOrNull("") - assertFailsOrNull(" ") - } - } @Test fun toDouble() { compareConversion(String::toDouble, String::toDoubleOrNull, ::doubleTotalOrderEquals) { @@ -172,121 +148,10 @@ class StringNumberConversionTest { assertFailsOrNull(" ") } } - - @kotlin.jvm.JvmVersion - @Test fun toHexDouble() { - compareConversion(String::toDouble, String::toDoubleOrNull, ::doubleTotalOrderEquals) { - assertProduces("0x77p1", (0x77 shl 1).toDouble()) - assertProduces("0x.77P8", 0x77.toDouble()) - - assertFailsOrNull("0x77e1") - } - } - - @kotlin.jvm.JvmVersion - @Test fun byteToStringWithRadix() { - assertEquals("7a", 0x7a.toByte().toString(16)) - assertEquals("-80", Byte.MIN_VALUE.toString(radix = 16)) - assertEquals("3v", Byte.MAX_VALUE.toString(radix = 32)) - assertEquals("-40", Byte.MIN_VALUE.toString(radix = 32)) - - assertFailsWith("Expected to fail with radix 37") { 37.toByte().toString(radix = 37) } - assertFailsWith("Expected to fail with radix 1") { 1.toByte().toString(radix = 1) } - } - - @kotlin.jvm.JvmVersion - @Test fun shortToStringWithRadix() { - assertEquals("7FFF", 0x7FFF.toShort().toString(radix = 16).toUpperCase()) - assertEquals("-8000", (-0x8000).toShort().toString(radix = 16)) - assertEquals("-sfs", (-29180).toShort().toString(radix = 32)) - - assertFailsWith("Expected to fail with radix 37") { 37.toShort().toString(radix = 37) } - assertFailsWith("Expected to fail with radix 1") { 1.toShort().toString(radix = 1) } - } - - @kotlin.jvm.JvmVersion - @Test fun intToStringWithRadix() { - assertEquals("-ff", (-255).toString(radix = 16)) - assertEquals("1100110", 102.toString(radix = 2)) - assertEquals("kona", 411787.toString(radix = 27)) - assertFailsWith("Expected to fail with radix 37") { 37.toString(radix = 37) } - assertFailsWith("Expected to fail with radix 1") { 1.toString(radix = 1) } - - } - - @kotlin.jvm.JvmVersion - @Test fun longToStringWithRadix() { - assertEquals("7f11223344556677", 0x7F11223344556677.toString(radix = 16)) - assertEquals("hazelnut", 1356099454469L.toString(radix = 36)) - assertEquals("-8000000000000000", Long.MIN_VALUE.toString(radix = 16)) - - assertFailsWith("Expected to fail with radix 37") { 37L.toString(radix = 37) } - assertFailsWith("Expected to fail with radix 1") { 1L.toString(radix = 1) } - } - - @kotlin.jvm.JvmVersion - @Test fun toBigInteger() { - compareConversion(String::toBigInteger, String::toBigIntegerOrNull) { - assertProduces("0", java.math.BigInteger.ZERO) - assertProduces("1", java.math.BigInteger.ONE) - assertProduces("-1", java.math.BigInteger.ONE.negate()) - assertProduces("100000000000000000000", java.math.BigInteger("100000000000000000000")) - assertFailsOrNull("") - assertFailsOrNull("-") - assertFailsOrNull("a") - assertFailsOrNull("-x") - assertFailsOrNull("1000 000") - } - - compareConversionWithRadix(String::toBigInteger, String::toBigIntegerOrNull) { - assertProduces(16, "ABCDEF90ABCDEF9012345678", java.math.BigInteger("ABCDEF90ABCDEF9012345678", 16)) - assertProduces(36, "HazelnutHazelnut", java.math.BigInteger.valueOf(1356099454469L).let { it.multiply(java.math.BigInteger.valueOf(36).pow(8)).add(it) }) - - assertFailsOrNull(16, "EFG") - assertFailsOrNull(10, "-1A") - assertFailsOrNull(2, "-") - assertFailsOrNull(3, "") - - assertFailsWith("Expected to fail with radix 37") { "37".toBigInteger(radix = 37) } - assertFailsWith("Expected to fail with radix 1") { "1".toBigIntegerOrNull(radix = 1) } - } - } - - @kotlin.jvm.JvmVersion - @Test fun toBigDecimal() { - fun bd(value: String) = java.math.BigDecimal(value) - compareConversion(String::toBigDecimal, String::toBigDecimalOrNull) { - - assertProduces("-77", bd("-77")) - assertProduces("-77.0", bd("-77.0")) - assertProduces("77.", bd("77")) - assertProduces("123456789012345678901234567890.123456789", bd("123456789012345678901234567890.123456789")) - assertProduces("-1.77", bd("-1.77")) - assertProduces("+.77", bd("0.77")) - assertProduces("7.7e1", bd("77")) - assertProduces("+770e-1", bd("77.0")) - - assertFailsOrNull("7..7") - assertFailsOrNull("\t-77 \n") - assertFailsOrNull("007 not a number") - assertFailsOrNull("") - assertFailsOrNull(" ") - } - - var mc = java.math.MathContext(3, java.math.RoundingMode.UP) - compareConversion( { it.toBigDecimal(mc) }, { it.toBigDecimalOrNull(mc) }) { - assertProduces("1.991", bd("2.00")) - - mc = java.math.MathContext(1, java.math.RoundingMode.UNNECESSARY) - - assertFailsWith { "2.991".toBigDecimal(mc) } - assertFailsWith { "2.991".toBigDecimalOrNull(mc) } - } - } } -private fun compareConversion(convertOrFail: (String) -> T, +internal fun compareConversion(convertOrFail: (String) -> T, convertOrNull: (String) -> T?, equality: (T, T?) -> Boolean = { a, b -> a == b }, assertions: ConversionContext.() -> Unit) { @@ -294,14 +159,14 @@ private fun compareConversion(convertOrFail: (String) -> T, } -private fun compareConversionWithRadix(convertOrFail: String.(Int) -> T, +internal fun compareConversionWithRadix(convertOrFail: String.(Int) -> T, convertOrNull: String.(Int) -> T?, assertions: ConversionWithRadixContext.() -> Unit) { ConversionWithRadixContext(convertOrFail, convertOrNull).assertions() } -private class ConversionContext(val convertOrFail: (String) -> T, +internal class ConversionContext(val convertOrFail: (String) -> T, val convertOrNull: (String) -> T?, val equality: (T, T?) -> Boolean) { @@ -320,7 +185,7 @@ private class ConversionContext(val convertOrFail: (String) -> T, } } -private class ConversionWithRadixContext(val convertOrFail: (String, Int) -> T, +internal class ConversionWithRadixContext(val convertOrFail: (String, Int) -> T, val convertOrNull: (String, Int) -> T?) { fun assertProduces(radix: Int, input: String, output: T) { assertEquals(output, convertOrFail(input.removeLeadingPlusOnJava6(), radix)) diff --git a/libraries/stdlib/test/utils/AssertionsJVMTest.kt b/libraries/stdlib/test/utils/AssertionsJVMTest.kt new file mode 100644 index 00000000000..22f2eea54fe --- /dev/null +++ b/libraries/stdlib/test/utils/AssertionsJVMTest.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +@file:JvmVersion +package test.utils + +import kotlin.test.* + +class AssertionsJVMTest() { + + @Test fun passingAssert() { + assert(true) + var called = false + assert(true) { called = true; "some message" } + + assertFalse(called) + } + + + @Test fun failingAssert() { + val error = assertFailsWith { + assert(false) + } + assertEquals("Assertion failed", error.message) + } + + + @Test fun failingAssertWithMessage() { + val error = assertFailsWith { + assert(false) { "Hello" } + } + assertEquals("Hello", error.message) + } + +} \ No newline at end of file diff --git a/libraries/stdlib/test/utils/KotlinVersionTest.kt b/libraries/stdlib/test/utils/KotlinVersionTest.kt index 71d55f625fe..3c88565f207 100644 --- a/libraries/stdlib/test/utils/KotlinVersionTest.kt +++ b/libraries/stdlib/test/utils/KotlinVersionTest.kt @@ -1,5 +1,6 @@ package test.utils +import test.randomInt import kotlin.test.* @@ -55,10 +56,8 @@ class KotlinVersionTest { } } - @JvmVersion // until there's random in JS @Test fun randomVersionComparison() { - val random = java.util.Random() - fun randomComponent(): Int = random.nextInt(KotlinVersion.MAX_COMPONENT_VALUE + 1) + fun randomComponent(): Int = randomInt(KotlinVersion.MAX_COMPONENT_VALUE + 1) fun randomVersion() = KotlinVersion(randomComponent(), randomComponent(), randomComponent()) repeat(1000) { val v1 = randomVersion() diff --git a/libraries/stdlib/test/utils/PreconditionsTest.kt b/libraries/stdlib/test/utils/PreconditionsTest.kt index 03bb2c5bff6..301a30d3f77 100644 --- a/libraries/stdlib/test/utils/PreconditionsTest.kt +++ b/libraries/stdlib/test/utils/PreconditionsTest.kt @@ -89,33 +89,6 @@ class PreconditionsTest() { } } - @kotlin.jvm.JvmVersion - @Test fun passingAssert() { - assert(true) - var called = false - assert(true) { called = true; "some message" } - - assertFalse(called) - } - - - @kotlin.jvm.JvmVersion - @Test fun failingAssert() { - val error = assertFailsWith { - assert(false) - } - assertEquals("Assertion failed", error.message) - } - - - @kotlin.jvm.JvmVersion - @Test fun failingAssertWithMessage() { - val error = assertFailsWith { - assert(false) { "Hello" } - } - assertEquals("Hello", error.message) - } - @Test fun error() { val error = assertFailsWith { error("There was a problem")