stdlib tests: move JVM-only test source files
This commit is contained in:
Ilya Gorbunov
@@ -1,17 +0,0 @@
|
||||
@file:kotlin.jvm.JvmVersion
|
||||
package test.text
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
class CharJVMTest {
|
||||
|
||||
@Test fun getCategory() {
|
||||
assertEquals(CharCategory.DECIMAL_DIGIT_NUMBER, '7'.category)
|
||||
assertEquals(CharCategory.CURRENCY_SYMBOL, '$'.category)
|
||||
assertEquals(CharCategory.LOWERCASE_LETTER, 'a'.category)
|
||||
assertEquals(CharCategory.UPPERCASE_LETTER, 'Õ'.category)
|
||||
|
||||
assertTrue(',' in CharCategory.OTHER_PUNCTUATION)
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,72 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2017 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.
|
||||
*/
|
||||
|
||||
@file:kotlin.jvm.JvmVersion
|
||||
package test.text
|
||||
|
||||
import kotlin.test.*
|
||||
import test.collections.compare
|
||||
import test.io.*
|
||||
import java.util.regex.Pattern
|
||||
|
||||
|
||||
class RegexJVMTest {
|
||||
|
||||
@Test fun matchGroups() {
|
||||
val input = "1a 2b 3c"
|
||||
val regex = "(\\d)(\\w)".toRegex()
|
||||
|
||||
val matches = regex.findAll(input).toList()
|
||||
assertTrue(matches.all { it.groups.size == 3 })
|
||||
val m1 = matches[0]
|
||||
assertEquals("1a", m1.groups[0]?.value)
|
||||
assertEquals(0..1, m1.groups[0]?.range)
|
||||
assertEquals("1", m1.groups[1]?.value)
|
||||
assertEquals(0..0, m1.groups[1]?.range)
|
||||
assertEquals("a", m1.groups[2]?.value)
|
||||
assertEquals(1..1, m1.groups[2]?.range)
|
||||
|
||||
val m2 = matches[1]
|
||||
assertEquals("2", m2.groups[1]?.value)
|
||||
assertEquals(3..3, m2.groups[1]?.range)
|
||||
assertEquals("b", m2.groups[2]?.value)
|
||||
assertEquals(4..4, m2.groups[2]?.range)
|
||||
}
|
||||
|
||||
|
||||
private fun compareRegex(expected: Regex, actual: Regex) = compare(expected, actual) {
|
||||
propertyEquals(Regex::pattern)
|
||||
propertyEquals(Regex::options)
|
||||
propertyEquals("flags") { toPattern().flags() }
|
||||
}
|
||||
|
||||
private fun equivalentAfterDeserialization(regex: Regex) = compareRegex(regex, serializeAndDeserialize(regex))
|
||||
|
||||
@Test fun serializeDeserializeRegex() {
|
||||
equivalentAfterDeserialization(Regex(""))
|
||||
equivalentAfterDeserialization(Regex("\\w+"))
|
||||
equivalentAfterDeserialization(Regex("\\w+", RegexOption.IGNORE_CASE))
|
||||
equivalentAfterDeserialization(Regex("\\w+", setOf(RegexOption.LITERAL, RegexOption.MULTILINE)))
|
||||
equivalentAfterDeserialization(Pattern.compile("\\w+", Pattern.UNICODE_CASE).toRegex())
|
||||
}
|
||||
|
||||
@Test fun deserializeRegexFromHex() {
|
||||
val expected = Regex("\\w+", RegexOption.IGNORE_CASE)
|
||||
// println(serializeToHex(expected))
|
||||
val deserialized = deserializeFromHex<Regex>("ac ed 00 05 73 72 00 1c 6b 6f 74 6c 69 6e 2e 74 65 78 74 2e 52 65 67 65 78 24 53 65 72 69 61 6c 69 7a 65 64 00 00 00 00 00 00 00 00 02 00 02 49 00 05 66 6c 61 67 73 4c 00 07 70 61 74 74 65 72 6e 74 00 12 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 78 70 00 00 00 42 74 00 03 5c 77 2b")
|
||||
compareRegex(expected, deserialized)
|
||||
}
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
@file:kotlin.jvm.JvmVersion
|
||||
package test.text
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
class StringBuilderJVMTest() {
|
||||
|
||||
@Test fun stringBuildWithInitialCapacity() {
|
||||
val s = buildString(123) {
|
||||
assertEquals(123, capacity())
|
||||
}
|
||||
assertEquals("", s)
|
||||
}
|
||||
|
||||
@Test fun getAndSetChar() {
|
||||
val sb = StringBuilder("abc")
|
||||
sb[1] = 'z'
|
||||
|
||||
assertEquals("azc", sb.toString())
|
||||
assertEquals('c', sb[2])
|
||||
}
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
@file:kotlin.jvm.JvmVersion
|
||||
package test.text
|
||||
|
||||
import test.collections.assertArrayNotSameButEquals
|
||||
import java.util.*
|
||||
import kotlin.test.*
|
||||
|
||||
|
||||
class StringJVMTest {
|
||||
|
||||
@Test fun testSplitByPattern() = withOneCharSequenceArg("ab1cd2def3") { s ->
|
||||
val isDigit = "\\d".toRegex()
|
||||
assertEquals(listOf("ab", "cd", "def", ""), s.split(isDigit))
|
||||
assertEquals(listOf("ab", "cd", "def3"), s.split(isDigit, 3))
|
||||
|
||||
// deprecation replacement equivalence
|
||||
assertEquals("\\d".toPattern().split(s).toList(), s.split("\\d".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray().toList())
|
||||
|
||||
assertFails {
|
||||
s.split(isDigit, -1)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun sliceCharSequenceFails() = withOneCharSequenceArg { arg1 ->
|
||||
assertFails {
|
||||
arg1("abc").slice(1..4)
|
||||
}
|
||||
assertFails {
|
||||
arg1("ABCDabcd").slice(listOf(10))
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun formatter() {
|
||||
assertEquals("12", "%d%d".format(1, 2))
|
||||
assertEquals("12", String.format("%d%d", 1, 2))
|
||||
|
||||
assertEquals("1,234,567.890", "%,.3f".format(Locale.ENGLISH, 1234567.890))
|
||||
assertEquals("1.234.567,890", "%,.3f".format(Locale.GERMAN, 1234567.890))
|
||||
assertEquals("1 234 567,890", "%,.3f".format(Locale("fr"), 1234567.890))
|
||||
assertEquals("1,234,567.890", String.format(Locale.ENGLISH, "%,.3f", 1234567.890))
|
||||
assertEquals("1.234.567,890", String.format(Locale.GERMAN, "%,.3f", 1234567.890))
|
||||
assertEquals("1 234 567,890", String.format(Locale("fr"), "%,.3f", 1234567.890))
|
||||
}
|
||||
|
||||
@Test fun toByteArrayEncodings() {
|
||||
val s = "hello®"
|
||||
assertEquals(String(s.toByteArray()), String(s.toByteArray(Charsets.UTF_8)))
|
||||
}
|
||||
|
||||
@Test fun toCharArray() {
|
||||
val s = "hello"
|
||||
val chars = s.toCharArray()
|
||||
assertArrayNotSameButEquals(charArrayOf('h', 'e', 'l', 'l', 'o'), chars)
|
||||
|
||||
val buffer = CharArray(4)
|
||||
s.toCharArray(buffer, 2, 1, 3)
|
||||
assertArrayNotSameButEquals(charArrayOf('\u0000', '\u0000', 'e', 'l'), buffer)
|
||||
}
|
||||
|
||||
@Test fun orderIgnoringCase() {
|
||||
val list = listOf("Beast", "Ast", "asterisk")
|
||||
assertEquals(listOf("Ast", "Beast", "asterisk"), list.sorted())
|
||||
assertEquals(listOf("Ast", "asterisk", "Beast"), list.sortedWith(String.CASE_INSENSITIVE_ORDER))
|
||||
}
|
||||
|
||||
@Test fun charsets() {
|
||||
assertEquals("UTF-32", Charsets.UTF_32.name())
|
||||
assertEquals("UTF-32LE", Charsets.UTF_32LE.name())
|
||||
assertEquals("UTF-32BE", Charsets.UTF_32BE.name())
|
||||
}
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
/*
|
||||
* 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) }
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user