azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor: extract JVM-specific tests into separate files

Browse Source 
Make KotlinVersion random comparison test running in JS
This commit is contained in:
Ilya Gorbunov
2018-03-21 18:52:00 +03:00
parent 2d099a29b8
commit 7a40b4c5f1
12 changed files with 260 additions and 204 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/stdlib/test/collections/MutableCollectionsJVMTest.kt
+29
View File
@@ -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)
}
}
libraries/stdlib/test/collections/MutableCollectionsTest.kt
-16
View File
@@ -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)
}
}
libraries/stdlib/test/properties/delegation/lazy/LazyValuesJVMTest.kt
+28
View File
@@ -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")
}
}
libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt
-19
View File
@@ -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) {
libraries/stdlib/test/testUtilsJVM.kt
+2
View File
@@ -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.")
libraries/stdlib/test/text/StringNumberConversionJVMTest.kt
+153
View File
@@ -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<IllegalArgumentException>("Expected to fail with radix 37") { 37.toByte().toString(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<IllegalArgumentException>("Expected to fail with radix 37") { 37.toShort().toString(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<IllegalArgumentException>("Expected to fail with radix 37") { 37.toString(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<IllegalArgumentException>("Expected to fail with radix 37") { 37L.toString(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<IllegalArgumentException>("Expected to fail with radix 37") { "37".toBigInteger(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<ArithmeticException> { "2.991".toBigDecimal(mc) }
assertFailsWith<ArithmeticException> { "2.991".toBigDecimalOrNull(mc) }
}
}
}
libraries/stdlib/test/text/StringNumberConversionTest.kt
+4 -139
View File
@@ -88,12 +88,6 @@ class StringNumberConversionTest {
assertFailsWith<IllegalArgumentException>("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<IllegalArgumentException>("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<IllegalArgumentException>("Expected to fail with radix 37") { 37.toByte().toString(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<IllegalArgumentException>("Expected to fail with radix 37") { 37.toShort().toString(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<IllegalArgumentException>("Expected to fail with radix 37") { 37.toString(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<IllegalArgumentException>("Expected to fail with radix 37") { 37L.toString(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<IllegalArgumentException>("Expected to fail with radix 37") { "37".toBigInteger(radix = 37) }
assertFailsWith<IllegalArgumentException>("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<ArithmeticException> { "2.991".toBigDecimal(mc) }
assertFailsWith<ArithmeticException> { "2.991".toBigDecimalOrNull(mc) }
}
}
}
private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
internal fun <T : Any> compareConversion(convertOrFail: (String) -> T,
convertOrNull: (String) -> T?,
equality: (T, T?) -> Boolean = { a, b -> a == b },
assertions: ConversionContext<T>.() -> Unit) {
@@ -294,14 +159,14 @@ private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
}
private fun <T : Any> compareConversionWithRadix(convertOrFail: String.(Int) -> T,
internal fun <T : Any> compareConversionWithRadix(convertOrFail: String.(Int) -> T,
convertOrNull: String.(Int) -> T?,
assertions: ConversionWithRadixContext<T>.() -> Unit) {
ConversionWithRadixContext(convertOrFail, convertOrNull).assertions()
}
private class ConversionContext<T: Any>(val convertOrFail: (String) -> T,
internal class ConversionContext<T: Any>(val convertOrFail: (String) -> T,
val convertOrNull: (String) -> T?,
val equality: (T, T?) -> Boolean) {
@@ -320,7 +185,7 @@ private class ConversionContext<T: Any>(val convertOrFail: (String) -> T,
}
}
private class ConversionWithRadixContext<T: Any>(val convertOrFail: (String, Int) -> T,
internal class ConversionWithRadixContext<T: Any>(val convertOrFail: (String, Int) -> T,
val convertOrNull: (String, Int) -> T?) {
fun assertProduces(radix: Int, input: String, output: T) {
assertEquals(output, convertOrFail(input.removeLeadingPlusOnJava6(), radix))
libraries/stdlib/test/utils/AssertionsJVMTest.kt
+37
View File
@@ -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<AssertionError> {
assert(false)
}
assertEquals("Assertion failed", error.message)
}
@Test fun failingAssertWithMessage() {
val error = assertFailsWith<AssertionError> {
assert(false) { "Hello" }
}
assertEquals("Hello", error.message)
}
}
libraries/stdlib/test/utils/KotlinVersionTest.kt
+2 -3
View File
@@ -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()
libraries/stdlib/test/utils/PreconditionsTest.kt
-27
View File
@@ -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<AssertionError> {
assert(false)
}
assertEquals("Assertion failed", error.message)
}
@kotlin.jvm.JvmVersion
@Test fun failingAssertWithMessage() {
val error = assertFailsWith<AssertionError> {
assert(false) { "Hello" }
}
assertEquals("Hello", error.message)
}
@Test fun error() {
val error = assertFailsWith<IllegalStateException> {
error("There was a problem")