tests: Copy stdlib tests from Kotlin/JVM

This patch copies Kotlin/JVM stdlib tests (libraries/stdlib/test)
excepting ones with explicit java dependencies. It also transforms
the tests to use them as box-tests.

backend.native/tests/external/stdlib/text/RegexTest/escapeLiteral.kt

@@ -0,0 +1,10 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val literal = """[-\/\\^$*+?.()|[\]{}]"""
+    assertTrue(Regex.fromLiteral(literal).matches(literal))
+    assertTrue(Regex.escape(literal).toRegex().matches(literal))
+}

backend.native/tests/external/stdlib/text/RegexTest/matchAllSequence.kt

@@ -0,0 +1,13 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val input = "test"
+    val pattern = ".*".toRegex()
+    val matches = pattern.findAll(input).toList()
+    assertEquals(input, matches[0].value)
+    assertEquals(input, matches.joinToString("") { it.value })
+    assertEquals(2, matches.size)
+}

backend.native/tests/external/stdlib/text/RegexTest/matchEntire.kt

@@ -0,0 +1,15 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val regex = "(\\d)(\\w)".toRegex()
+
+    assertNull(regex.matchEntire("1a 2b"))
+    assertNotNull(regex.matchEntire("3c")) { m ->
+        assertEquals("3c", m.value)
+        assertEquals(3, m.groups.size)
+        assertEquals(listOf("3c", "3", "c"), m.groups.map { it!!.value })
+    }
+}

backend.native/tests/external/stdlib/text/RegexTest/matchEntireLazyQuantor.kt

@@ -0,0 +1,12 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val regex = "a+b+?".toRegex()
+    val input = StringBuilder("aaaabbbb")
+
+    assertEquals("aaaab", regex.find(input)!!.value)
+    assertEquals("aaaabbbb", regex.matchEntire(input)!!.value)
+}

backend.native/tests/external/stdlib/text/RegexTest/matchGroups.kt

@@ -0,0 +1,38 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val input = "1a 2b 3c"
+    val pattern = "(\\d)(\\w)".toRegex()
+
+    val matches = pattern.findAll(input).toList()
+    assertTrue(matches.all { it.groups.size == 3 })
+
+    matches[0].let { m ->
+        assertEquals("1a", m.groups[0]?.value)
+        assertEquals("1", m.groups[1]?.value)
+        assertEquals("a", m.groups[2]?.value)
+
+        assertEquals(listOf("1a", "1", "a"), m.groupValues)
+
+        val (g1, g2) = m.destructured
+        assertEquals("1", g1)
+        assertEquals("a", g2)
+        assertEquals(listOf("1", "a"), m.destructured.toList())
+    }
+
+    matches[1].let { m ->
+        assertEquals("2b", m.groups[0]?.value)
+        assertEquals("2", m.groups[1]?.value)
+        assertEquals("b", m.groups[2]?.value)
+
+        assertEquals(listOf("2b", "2", "b"), m.groupValues)
+
+        val (g1, g2) = m.destructured
+        assertEquals("2", g1)
+        assertEquals("b", g2)
+        assertEquals(listOf("2", "b"), m.destructured.toList())
+    }
+}

backend.native/tests/external/stdlib/text/RegexTest/matchIgnoreCase.kt

@@ -0,0 +1,9 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    for (input in listOf("ascii", "shrödinger"))
+        assertTrue(input.toUpperCase().matches(input.toLowerCase().toRegex(RegexOption.IGNORE_CASE)))
+}

backend.native/tests/external/stdlib/text/RegexTest/matchMultiline.kt

@@ -0,0 +1,10 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val regex = "^[a-z]*$".toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
+    val matchedValues = regex.findAll("test\n\nLine").map { it.value }.toList()
+    assertEquals(listOf("test", "", "Line"), matchedValues)
+}

backend.native/tests/external/stdlib/text/RegexTest/matchOptionalGroup.kt

@@ -0,0 +1,34 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val pattern = "(hi)|(bye)".toRegex(RegexOption.IGNORE_CASE)
+
+    pattern.find("Hi!")!!.let { m ->
+        assertEquals(3, m.groups.size)
+        assertEquals("Hi", m.groups[1]?.value)
+        assertEquals(null, m.groups[2])
+
+        assertEquals(listOf("Hi", "Hi", ""), m.groupValues)
+
+        val (g1, g2) = m.destructured
+        assertEquals("Hi", g1)
+        assertEquals("", g2)
+        assertEquals(listOf("Hi", ""), m.destructured.toList())
+    }
+
+    pattern.find("bye...")!!.let { m ->
+        assertEquals(3, m.groups.size)
+        assertEquals(null, m.groups[1])
+        assertEquals("bye", m.groups[2]?.value)
+
+        assertEquals(listOf("bye", "", "bye"), m.groupValues)
+
+        val (g1, g2) = m.destructured
+        assertEquals("", g1)
+        assertEquals("bye", g2)
+        assertEquals(listOf("", "bye"), m.destructured.toList())
+    }
+}

backend.native/tests/external/stdlib/text/RegexTest/matchResult.kt

@@ -0,0 +1,32 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val p = "\\d+".toRegex()
+    val input = "123 456 789"
+
+    assertFalse(input matches p)
+    assertFalse(p matches input)
+
+    assertTrue(p in input)
+
+    val first = p.find(input)
+    assertTrue(first != null); first!!
+    assertEquals("123", first.value)
+
+    val second1 = first.next()!!
+    val second2 = first.next()!!
+
+    assertEquals("456", second1.value)
+    assertEquals(second1.value, second2.value)
+
+    assertEquals("56", p.find(input, startIndex = 5)?.value)
+
+    val last = second1.next()!!
+    assertEquals("789", last.value)
+
+    val noMatch = last.next()
+    assertEquals(null, noMatch)
+}

backend.native/tests/external/stdlib/text/RegexTest/matchSequence.kt

@@ -0,0 +1,18 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val input = "123 456 789"
+    val pattern = "\\d+".toRegex()
+
+    val matches = pattern.findAll(input)
+    val values = matches.map { it.value }
+    val expected = listOf("123", "456", "789")
+    assertEquals(expected, values.toList())
+    assertEquals(expected, values.toList(), "running match sequence second time")
+    assertEquals(expected.drop(1), pattern.findAll(input, startIndex = 3).map { it.value }.toList())
+
+    assertEquals(listOf(0..2, 4..6, 8..10), matches.map { it.range }.toList())
+}

backend.native/tests/external/stdlib/text/RegexTest/replace.kt

@@ -0,0 +1,13 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val input = "123-456"
+    val pattern = "(\\d+)".toRegex()
+    assertEquals("(123)-(456)", pattern.replace(input, "($1)"))
+
+    assertEquals("$&-$&", pattern.replace(input, Regex.escapeReplacement("$&")))
+    assertEquals("X-456", pattern.replaceFirst(input, "X"))
+}

backend.native/tests/external/stdlib/text/RegexTest/replaceEvaluator.kt

@@ -0,0 +1,10 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val input = "/12/456/7890/"
+    val pattern = "\\d+".toRegex()
+    assertEquals("/2/3/4/", pattern.replace(input, { it.value.length.toString() } ))
+}

backend.native/tests/external/stdlib/text/RegexTest/split.kt

@@ -0,0 +1,16 @@
+import kotlin.text.*
+
+import kotlin.test.*
+
+
+fun box() {
+    val input = """
+     some  ${"\t"}  word
+     split
+    """.trim()
+
+    assertEquals(listOf("some", "word", "split"), "\\s+".toRegex().split(input))
+
+    assertEquals(listOf("name", "value=5"), "=".toRegex().split("name=value=5", limit = 2))
+
+}

backend.native/tests/external/stdlib/text/StringBuilderTest/append.kt

@@ -0,0 +1,9 @@
+import kotlin.test.*
+
+
+fun box() {
+    // this test is needed for JS implementation
+    assertEquals("em", buildString {
+        append("element", 2, 4)
+    })
+}

backend.native/tests/external/stdlib/text/StringBuilderTest/appendMany.kt

@@ -0,0 +1,8 @@
+import kotlin.test.*
+
+
+fun box() {
+    assertEquals("a1", StringBuilder().append("a", "1").toString())
+    assertEquals("a1", StringBuilder().append("a", 1).toString())
+    assertEquals("a1", StringBuilder().append("a", StringBuilder().append("1")).toString())
+}

backend.native/tests/external/stdlib/text/StringBuilderTest/asCharSequence.kt

@@ -0,0 +1,17 @@
+import kotlin.test.*
+
+
+fun box() {
+    val original = "Some test string"
+    val sb = StringBuilder(original)
+    val result = sb.toString()
+    val cs = sb as CharSequence
+
+    assertEquals(result.length, cs.length)
+    assertEquals(result.length, sb.length)
+    for (index in result.indices) {
+        assertEquals(result[index], sb[index])
+        assertEquals(result[index], cs[index])
+    }
+    assertEquals(result.substring(2, 6), cs.subSequence(2, 6).toString())
+}

backend.native/tests/external/stdlib/text/StringBuilderTest/constructors.kt

@@ -0,0 +1,24 @@
+import kotlin.test.*
+
+
+fun box() {
+    StringBuilder().let { sb ->
+        assertEquals(0, sb.length)
+        assertEquals("", sb.toString())
+    }
+
+    StringBuilder(16).let { sb ->
+        assertEquals(0, sb.length)
+        assertEquals("", sb.toString())
+    }
+
+    StringBuilder("content").let { sb ->
+        assertEquals(7, sb.length)
+        assertEquals("content", sb.toString())
+    }
+
+    StringBuilder(StringBuilder("content")).let { sb ->
+        assertEquals(7, sb.length)
+        assertEquals("content", sb.toString())
+    }
+}

backend.native/tests/external/stdlib/text/StringBuilderTest/stringBuild.kt

@@ -0,0 +1,10 @@
+import kotlin.test.*
+
+
+fun box() {
+    val s = buildString {
+        append("a")
+        append(true)
+    }
+    assertEquals("atrue", s)
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/byteToStringWithRadix.kt

@@ -0,0 +1,13 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    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) }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/intToStringWithRadix.kt

@@ -0,0 +1,11 @@
+import kotlin.test.*
+
+
+fun box() {
+    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) }
+
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/longToStringWithRadix.kt

@@ -0,0 +1,12 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    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) }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/shortToStringWithRadix.kt

@@ -0,0 +1,12 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    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) }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toBoolean.kt

@@ -0,0 +1,8 @@
+import kotlin.test.*
+
+fun box() {
+    assertEquals(true, "true".toBoolean())
+    assertEquals(true, "True".toBoolean())
+    assertEquals(false, "false".toBoolean())
+    assertEquals(false, "not so true".toBoolean())
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toByte.kt

@@ -0,0 +1,69 @@
+import kotlin.test.*
+
+
+private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+                                        convertOrNull: (String) -> T?,
+                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+                                        assertions: ConversionContext<T>.() -> Unit) {
+    ConversionContext(convertOrFail, convertOrNull, equality).assertions()
+}
+
+private 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,
+                                        val convertOrNull: (String) -> T?,
+                                        val equality: (T, T?) -> Boolean) {
+
+    private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
+        assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
+    }
+
+    fun assertProduces(input: String, output: T) {
+        assertEquals(output, convertOrFail(input), input, "convertOrFail")
+        assertEquals(output, convertOrNull(input), input, "convertOrNull")
+    }
+
+    fun assertFailsOrNull(input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\"") { convertOrFail(input) }
+        assertNull(convertOrNull(input), message = "On input \"$input\"")
+    }
+}
+
+private 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, radix))
+        assertEquals(output, convertOrNull(input, radix))
+    }
+
+    fun assertFailsOrNull(radix: Int, input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\" with radix $radix",
+                                               { convertOrFail(input, radix) })
+
+        assertNull(convertOrNull(input, radix), message = "On input \"$input\" with radix $radix")
+    }
+}
+
+fun box() {
+    compareConversion({it.toByte()}, {it.toByteOrNull()}) {
+        assertProduces("127", Byte.MAX_VALUE)
+        assertProduces("+77", 77.toByte())
+        assertProduces("-128", Byte.MIN_VALUE)
+        assertFailsOrNull("128")
+        assertFailsOrNull("")
+        assertFailsOrNull("   ")
+    }
+
+    compareConversionWithRadix(String::toByte, String::toByteOrNull) {
+        assertProduces(16, "7a", 0x7a.toByte())
+        assertProduces(16, "+7F", 127.toByte())
+        assertProduces(16, "-80", (-128).toByte())
+        assertFailsOrNull(2, "10000000")
+        assertFailsOrNull(8, "")
+        assertFailsOrNull(8, "   ")
+    }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toDouble.kt

@@ -0,0 +1,74 @@
+import kotlin.test.*
+
+
+private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+                                        convertOrNull: (String) -> T?,
+                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+                                        assertions: ConversionContext<T>.() -> Unit) {
+    ConversionContext(convertOrFail, convertOrNull, equality).assertions()
+}
+
+
+private 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,
+                                        val convertOrNull: (String) -> T?,
+                                        val equality: (T, T?) -> Boolean) {
+
+    private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
+        assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
+    }
+
+    fun assertProduces(input: String, output: T) {
+        assertEquals(output, convertOrFail(input), input, "convertOrFail")
+        assertEquals(output, convertOrNull(input), input, "convertOrNull")
+    }
+
+    fun assertFailsOrNull(input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\"") { convertOrFail(input) }
+        assertNull(convertOrNull(input), message = "On input \"$input\"")
+    }
+}
+
+private 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, radix))
+        assertEquals(output, convertOrNull(input, radix))
+    }
+
+    fun assertFailsOrNull(radix: Int, input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\" with radix $radix",
+                                               { convertOrFail(input, radix) })
+
+        assertNull(convertOrNull(input, radix), message = "On input \"$input\" with radix $radix")
+    }
+}
+
+private fun doubleTotalOrderEquals(a: Any?, b: Any?) = a == b
+
+fun box() {
+    compareConversion(String::toDouble, String::toDoubleOrNull, ::doubleTotalOrderEquals) {
+        assertProduces("-77", -77.0)
+        assertProduces("77.", 77.0)
+        assertProduces("77.0", 77.0)
+        assertProduces("-1.77", -1.77)
+        assertProduces("+.77", 0.77)
+        assertProduces("\t-77 \n", -77.0)
+        assertProduces("7.7e1", 77.0)
+        assertProduces("+770e-1", 77.0)
+
+        assertProduces("-NaN", -Double.NaN)
+        assertProduces("+Infinity", Double.POSITIVE_INFINITY)
+
+        assertFailsOrNull("7..7")
+        assertFailsOrNull("007 not a number")
+        assertFailsOrNull("")
+        assertFailsOrNull("   ")
+    }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toFloat.kt

@@ -0,0 +1,63 @@
+import kotlin.test.*
+
+
+
+private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+                                        convertOrNull: (String) -> T?,
+                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+                                        assertions: ConversionContext<T>.() -> Unit) {
+    ConversionContext(convertOrFail, convertOrNull, equality).assertions()
+}
+
+
+private 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,
+                                        val convertOrNull: (String) -> T?,
+                                        val equality: (T, T?) -> Boolean) {
+
+    private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
+        assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
+    }
+
+    fun assertProduces(input: String, output: T) {
+        assertEquals(output, convertOrFail(input), input, "convertOrFail")
+        assertEquals(output, convertOrNull(input), input, "convertOrNull")
+    }
+
+    fun assertFailsOrNull(input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\"") { convertOrFail(input) }
+        assertNull(convertOrNull(input), message = "On input \"$input\"")
+    }
+}
+
+private 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, radix))
+        assertEquals(output, convertOrNull(input, radix))
+    }
+
+    fun assertFailsOrNull(radix: Int, input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\" with radix $radix",
+                                               { convertOrFail(input, radix) })
+
+        assertNull(convertOrNull(input, radix), message = "On input \"$input\" with radix $radix")
+    }
+}
+
+fun box() {
+    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("   ")
+    }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toHexDouble.kt

@@ -0,0 +1,62 @@
+import kotlin.test.*
+
+
+private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+                                        convertOrNull: (String) -> T?,
+                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+                                        assertions: ConversionContext<T>.() -> Unit) {
+    ConversionContext(convertOrFail, convertOrNull, equality).assertions()
+}
+
+
+private 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,
+                                        val convertOrNull: (String) -> T?,
+                                        val equality: (T, T?) -> Boolean) {
+
+    private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
+        assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
+    }
+
+    fun assertProduces(input: String, output: T) {
+        assertEquals(output, convertOrFail(input), input, "convertOrFail")
+        assertEquals(output, convertOrNull(input), input, "convertOrNull")
+    }
+
+    fun assertFailsOrNull(input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\"") { convertOrFail(input) }
+        assertNull(convertOrNull(input), message = "On input \"$input\"")
+    }
+}
+
+private 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, radix))
+        assertEquals(output, convertOrNull(input, radix))
+    }
+
+    fun assertFailsOrNull(radix: Int, input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\" with radix $radix",
+                                               { convertOrFail(input, radix) })
+
+        assertNull(convertOrNull(input, radix), message = "On input \"$input\" with radix $radix")
+    }
+}
+
+private fun doubleTotalOrderEquals(a: Any?, b: Any?) = a == b
+
+fun box() {
+    compareConversion(String::toDouble, String::toDoubleOrNull, ::doubleTotalOrderEquals) {
+        assertProduces("0x77p1", (0x77 shl 1).toDouble())
+        assertProduces("0x.77P8", 0x77.toDouble())
+
+        assertFailsOrNull("0x77e1")
+    }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toInt.kt

@@ -0,0 +1,88 @@
+import kotlin.test.*
+
+
+private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+                                        convertOrNull: (String) -> T?,
+                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+                                        assertions: ConversionContext<T>.() -> Unit) {
+    ConversionContext(convertOrFail, convertOrNull, equality).assertions()
+}
+
+
+private 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,
+                                        val convertOrNull: (String) -> T?,
+                                        val equality: (T, T?) -> Boolean) {
+
+    private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
+        assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
+    }
+
+    fun assertProduces(input: String, output: T) {
+        assertEquals(output, convertOrFail(input), input, "convertOrFail")
+        assertEquals(output, convertOrNull(input), input, "convertOrNull")
+    }
+
+    fun assertFailsOrNull(input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\"") { convertOrFail(input) }
+        assertNull(convertOrNull(input), message = "On input \"$input\"")
+    }
+}
+
+private 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, radix))
+        assertEquals(output, convertOrNull(input, radix))
+    }
+
+    fun assertFailsOrNull(radix: Int, input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\" with radix $radix",
+                                               { convertOrFail(input, radix) })
+
+        assertNull(convertOrNull(input, radix), message = "On input \"$input\" with radix $radix")
+    }
+}
+
+fun box() {
+    compareConversion({it.toInt()}, {it.toIntOrNull()}) {
+        assertProduces("77", 77)
+        assertProduces("+2147483647", Int.MAX_VALUE)
+        assertProduces("-2147483648", Int.MIN_VALUE)
+
+        assertFailsOrNull("2147483648")
+        assertFailsOrNull("-2147483649")
+        assertFailsOrNull("239239kotlin")
+        assertFailsOrNull("")
+        assertFailsOrNull("   ")
+    }
+
+    compareConversionWithRadix(String::toInt, String::toIntOrNull) {
+        assertProduces(10, "0", 0)
+        assertProduces(10, "473", 473)
+        assertProduces(10, "+42", 42)
+        assertProduces(10, "-0", 0)
+        assertProduces(10, "2147483647", 2147483647)
+        assertProduces(10, "-2147483648", -2147483648)
+
+        assertProduces(16, "-FF", -255)
+        assertProduces(16, "-ff", -255)
+        assertProduces(2, "1100110", 102)
+        assertProduces(27, "Kona", 411787)
+
+        assertFailsOrNull(10, "2147483648")
+        assertFailsOrNull(8, "99")
+        assertFailsOrNull(10, "Kona")
+        assertFailsOrNull(16, "")
+        assertFailsOrNull(16, "  ")
+    }
+
+    assertFailsWith<IllegalArgumentException>("Expected to fail with radix 1") { "1".toInt(radix = 1) }
+    assertFailsWith<IllegalArgumentException>("Expected to fail with radix 37") { "37".toIntOrNull(radix = 37) }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toIntArabicDigits.kt

@@ -0,0 +1,57 @@
+import kotlin.test.*
+
+
+private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+                                        convertOrNull: (String) -> T?,
+                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+                                        assertions: ConversionContext<T>.() -> Unit) {
+    ConversionContext(convertOrFail, convertOrNull, equality).assertions()
+}
+
+
+private 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,
+                                        val convertOrNull: (String) -> T?,
+                                        val equality: (T, T?) -> Boolean) {
+
+    private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
+        assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
+    }
+
+    fun assertProduces(input: String, output: T) {
+        assertEquals(output, convertOrFail(input), input, "convertOrFail")
+        assertEquals(output, convertOrNull(input), input, "convertOrNull")
+    }
+
+    fun assertFailsOrNull(input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\"") { convertOrFail(input) }
+        assertNull(convertOrNull(input), message = "On input \"$input\"")
+    }
+}
+
+private 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, radix))
+        assertEquals(output, convertOrNull(input, radix))
+    }
+
+    fun assertFailsOrNull(radix: Int, input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\" with radix $radix",
+                                               { convertOrFail(input, radix) })
+
+        assertNull(convertOrNull(input, radix), message = "On input \"$input\" with radix $radix")
+    }
+}
+
+fun box() {
+    compareConversion({ it.toInt() }, { it.toIntOrNull() }) {
+        assertProduces("٢٣١٩٦٠", 231960)
+    }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toLong.kt

@@ -0,0 +1,89 @@
+import kotlin.test.*
+
+
+private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+                                        convertOrNull: (String) -> T?,
+                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+                                        assertions: ConversionContext<T>.() -> Unit) {
+    ConversionContext(convertOrFail, convertOrNull, equality).assertions()
+}
+
+
+private 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,
+                                        val convertOrNull: (String) -> T?,
+                                        val equality: (T, T?) -> Boolean) {
+
+    private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
+        assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
+    }
+
+    fun assertProduces(input: String, output: T) {
+        assertEquals(output, convertOrFail(input), input, "convertOrFail")
+        assertEquals(output, convertOrNull(input), input, "convertOrNull")
+    }
+
+    fun assertFailsOrNull(input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\"") { convertOrFail(input) }
+        assertNull(convertOrNull(input), message = "On input \"$input\"")
+    }
+}
+
+private 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, radix))
+        assertEquals(output, convertOrNull(input, radix))
+    }
+
+    fun assertFailsOrNull(radix: Int, input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\" with radix $radix",
+                                               { convertOrFail(input, radix) })
+
+        assertNull(convertOrNull(input, radix), message = "On input \"$input\" with radix $radix")
+    }
+}
+
+fun box() {
+    compareConversion({it.toLong()}, {it.toLongOrNull()}) {
+        assertProduces("77", 77.toLong())
+        assertProduces("+9223372036854775807", Long.MAX_VALUE)
+        assertProduces("-9223372036854775808", Long.MIN_VALUE)
+
+        assertFailsOrNull("9223372036854775808")
+        assertFailsOrNull("-9223372036854775809")
+        assertFailsOrNull("922337 75809")
+        assertFailsOrNull("92233,75809")
+        assertFailsOrNull("92233`75809")
+        assertFailsOrNull("-922337KOTLIN775809")
+        assertFailsOrNull("")
+        assertFailsOrNull("  ")
+    }
+
+    compareConversionWithRadix(String::toLong, String::toLongOrNull) {
+        assertProduces(10, "0", 0L)
+        assertProduces(10, "473", 473L)
+        assertProduces(10, "+42", 42L)
+        assertProduces(10, "-0", 0L)
+
+        assertProduces(16, "7F11223344556677", 0x7F11223344556677)
+        assertProduces(16, "+7faabbccddeeff00", 0x7faabbccddeeff00)
+        assertProduces(16, "-8000000000000000", Long.MIN_VALUE)
+        assertProduces(2, "1100110", 102L)
+        assertProduces(36, "Hazelnut", 1356099454469L)
+
+        assertFailsOrNull(8, "99")
+        assertFailsOrNull(10, "Hazelnut")
+        assertFailsOrNull(4, "")
+        assertFailsOrNull(4, "  ")
+    }
+
+    assertFailsWith<IllegalArgumentException>("Expected to fail with radix 37") { "37".toLong(radix = 37) }
+    assertFailsWith<IllegalArgumentException>("Expected to fail with radix 1") { "1".toLongOrNull(radix = 1) }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toLongArabicDigits.kt

@@ -0,0 +1,34 @@
+import kotlin.test.*
+
+
+private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+                                        convertOrNull: (String) -> T?,
+                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+                                        assertions: ConversionContext<T>.() -> Unit) {
+    ConversionContext(convertOrFail, convertOrNull, equality).assertions()
+}
+
+private class ConversionContext<T: Any>(val convertOrFail: (String) -> T,
+                                        val convertOrNull: (String) -> T?,
+                                        val equality: (T, T?) -> Boolean) {
+
+    private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
+        assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
+    }
+
+    fun assertProduces(input: String, output: T) {
+        assertEquals(output, convertOrFail(input), input, "convertOrFail")
+        assertEquals(output, convertOrNull(input), input, "convertOrNull")
+    }
+
+    fun assertFailsOrNull(input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\"") { convertOrFail(input) }
+        assertNull(convertOrNull(input), message = "On input \"$input\"")
+    }
+}
+
+fun box() {
+    compareConversion({ it.toLong() }, { it.toLongOrNull() }) {
+        assertProduces("٢٣١٩٦٠٧٧٨٤٥٩", 231960778459)
+    }
+}

backend.native/tests/external/stdlib/text/StringNumberConversionTest/toShort.kt

@@ -0,0 +1,70 @@
+import kotlin.test.*
+
+
+private fun <T : Any> compareConversion(convertOrFail: (String) -> T,
+                                        convertOrNull: (String) -> T?,
+                                        equality: (T, T?) -> Boolean = { a, b -> a == b },
+                                        assertions: ConversionContext<T>.() -> Unit) {
+    ConversionContext(convertOrFail, convertOrNull, equality).assertions()
+}
+
+
+private 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,
+                                        val convertOrNull: (String) -> T?,
+                                        val equality: (T, T?) -> Boolean) {
+
+    private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
+        assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
+    }
+
+    fun assertProduces(input: String, output: T) {
+        assertEquals(output, convertOrFail(input), input, "convertOrFail")
+        assertEquals(output, convertOrNull(input), input, "convertOrNull")
+    }
+
+    fun assertFailsOrNull(input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\"") { convertOrFail(input) }
+        assertNull(convertOrNull(input), message = "On input \"$input\"")
+    }
+}
+
+private 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, radix))
+        assertEquals(output, convertOrNull(input, radix))
+    }
+
+    fun assertFailsOrNull(radix: Int, input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\" with radix $radix",
+                                               { convertOrFail(input, radix) })
+
+        assertNull(convertOrNull(input, radix), message = "On input \"$input\" with radix $radix")
+    }
+}
+
+fun box() {
+    compareConversion({it.toShort()}, {it.toShortOrNull()}) {
+        assertProduces("+77", 77.toShort())
+        assertProduces("32767", Short.MAX_VALUE)
+        assertProduces("-32768", Short.MIN_VALUE)
+        assertFailsOrNull("+32768")
+        assertFailsOrNull("")
+        assertFailsOrNull("   ")
+    }
+
+    compareConversionWithRadix(String::toShort, String::toShortOrNull) {
+        assertProduces(16, "7FFF", 0x7FFF.toShort())
+        assertProduces(16, "-8000", (-0x8000).toShort())
+        assertFailsOrNull(5, "10000000")
+        assertFailsOrNull(2, "")
+        assertFailsOrNull(2, "   ")
+    }
+}

backend.native/tests/external/stdlib/text/StringTest/capitalize.kt

@@ -0,0 +1,10 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    assertEquals("A", "A".capitalize())
+    assertEquals("A", "a".capitalize())
+    assertEquals("Abcd", "abcd".capitalize())
+    assertEquals("Abcd", "Abcd".capitalize())
+}

backend.native/tests/external/stdlib/text/StringTest/decapitalize.kt

@@ -0,0 +1,11 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    assertEquals("a", "A".decapitalize())
+    assertEquals("a", "a".decapitalize())
+    assertEquals("abcd", "abcd".decapitalize())
+    assertEquals("abcd", "Abcd".decapitalize())
+    assertEquals("uRL", "URL".decapitalize())
+}

backend.native/tests/external/stdlib/text/StringTest/drop.kt

@@ -0,0 +1,12 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val data = "abcd1234"
+    assertEquals("d1234", data.drop(3))
+    assertFails {
+        data.drop(-2)
+    }
+    assertEquals("", data.drop(data.length + 5))
+}

backend.native/tests/external/stdlib/text/StringTest/dropWhile.kt

@@ -0,0 +1,13 @@
+import kotlin.test.*
+
+// helper predicates available on both platforms
+fun Char.isAsciiDigit() = this in '0'..'9'
+fun Char.isAsciiLetter() = this in 'A'..'Z' || this in 'a'..'z'
+fun Char.isAsciiUpperCase() = this in 'A'..'Z'
+
+fun box() {
+    val data = "ab1cd2"
+    assertEquals("1cd2", data.dropWhile { it.isAsciiLetter() })
+    assertEquals("", data.dropWhile { true })
+    assertEquals("ab1cd2", data.dropWhile { false })
+}

backend.native/tests/external/stdlib/text/StringTest/endsWithString.kt

@@ -0,0 +1,14 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    assertTrue("abcd".endsWith("d"))
+    assertTrue("abcd".endsWith("abcd"))
+    assertFalse("abcd".endsWith("b"))
+    assertFalse("strö".endsWith("RÖ", ignoreCase = false))
+    assertTrue("strö".endsWith("RÖ", ignoreCase = true))
+    assertFalse("".endsWith("a"))
+    assertTrue("some".endsWith(""))
+    assertTrue("".endsWith(""))
+}

backend.native/tests/external/stdlib/text/StringTest/equalsIgnoreCase.kt

@@ -0,0 +1,12 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    assertFalse("sample".equals("Sample", ignoreCase = false))
+    assertTrue("sample".equals("Sample", ignoreCase = true))
+    assertFalse("sample".equals(null, ignoreCase = false))
+    assertFalse("sample".equals(null, ignoreCase = true))
+    assertTrue(null.equals(null, ignoreCase = true))
+    assertTrue(null.equals(null, ignoreCase = false))
+}

backend.native/tests/external/stdlib/text/StringTest/filter.kt

@@ -0,0 +1,11 @@
+import kotlin.test.*
+
+// helper predicates available on both platforms
+fun Char.isAsciiDigit() = this in '0'..'9'
+fun Char.isAsciiLetter() = this in 'A'..'Z' || this in 'a'..'z'
+fun Char.isAsciiUpperCase() = this in 'A'..'Z'
+
+fun box() {
+    assertEquals("acdca", ("abcdcba").filter { !it.equals('b') })
+    assertEquals("1234", ("a1b2c3d4").filter { it.isAsciiDigit() })
+}

backend.native/tests/external/stdlib/text/StringTest/filterIndexed.kt

@@ -0,0 +1,8 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val data = "abedcf"
+    assertEquals("abdf", data.filterIndexed { index, c -> c == 'a' + index })
+}

backend.native/tests/external/stdlib/text/StringTest/filterNot.kt

@@ -0,0 +1,11 @@
+import kotlin.test.*
+
+// helper predicates available on both platforms
+fun Char.isAsciiDigit() = this in '0'..'9'
+fun Char.isAsciiLetter() = this in 'A'..'Z' || this in 'a'..'z'
+fun Char.isAsciiUpperCase() = this in 'A'..'Z'
+
+fun box() {
+    assertEquals("acdca", ("abcdcba").filterNot { it.equals('b') })
+    assertEquals("abcd", ("a1b2c3d4").filterNot { it.isAsciiDigit() })
+}

backend.native/tests/external/stdlib/text/StringTest/joinTo.kt

@@ -0,0 +1,10 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val data = "kotlin".toList()
+    val sb = StringBuilder()
+    data.joinTo(sb, "^", "<", ">")
+    assertEquals("<k^o^t^l^i^n>", sb.toString())
+}

backend.native/tests/external/stdlib/text/StringTest/joinToString.kt

@@ -0,0 +1,17 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val data = "abcd".toList()
+    val result = data.joinToString("_", "(", ")")
+    assertEquals("(a_b_c_d)", result)
+
+    val data2 = "verylongstring".toList()
+    val result2 = data2.joinToString("-", "[", "]", 11, "oops")
+    assertEquals("[v-e-r-y-l-o-n-g-s-t-r-oops]", result2)
+
+    val data3 = "a1/b".toList()
+    val result3 = data3.joinToString() { it.toUpperCase().toString() }
+    assertEquals("A, 1, /, B", result3)
+}

backend.native/tests/external/stdlib/text/StringTest/orEmpty.kt

@@ -0,0 +1,11 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val s: String? = "hey"
+    val ns: String? = null
+
+    assertEquals("hey", s.orEmpty())
+    assertEquals("", ns.orEmpty())
+}

backend.native/tests/external/stdlib/text/StringTest/partition.kt

@@ -0,0 +1,13 @@
+import kotlin.test.*
+
+// helper predicates available on both platforms
+fun Char.isAsciiDigit() = this in '0'..'9'
+fun Char.isAsciiLetter() = this in 'A'..'Z' || this in 'a'..'z'
+fun Char.isAsciiUpperCase() = this in 'A'..'Z'
+
+fun box() {
+    val data = "a1b2c3"
+    val pair = data.partition { it.isAsciiDigit() }
+    assertEquals("123", pair.first, "pair.first")
+    assertEquals("abc", pair.second, "pair.second")
+}

backend.native/tests/external/stdlib/text/StringTest/replace.kt

@@ -0,0 +1,14 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val input = "abbAb"
+    assertEquals("abb${'$'}b", input.replace('A', '$'))
+    assertEquals("/bb/b", input.replace('A', '/', ignoreCase = true))
+
+    assertEquals("${'$'}bAb", input.replace("ab", "$"))
+    assertEquals("/b/", input.replace("ab", "/", ignoreCase = true))
+
+    assertEquals("-a-b-b-A-b-", input.replace("", "-"))
+}

backend.native/tests/external/stdlib/text/StringTest/replaceDelimited.kt

@@ -0,0 +1,26 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val s = "/user/folder/file.extension"
+    // chars
+    assertEquals("/user/folder/file.doc", s.replaceAfter('.', "doc"))
+    assertEquals("/user/folder/another.doc", s.replaceAfterLast('/', "another.doc"))
+    assertEquals("new name.extension", s.replaceBefore('.', "new name"))
+    assertEquals("/new/path/file.extension", s.replaceBeforeLast('/', "/new/path"))
+
+    // strings
+    assertEquals("/user/folder/file.doc", s.replaceAfter(".", "doc"))
+    assertEquals("/user/folder/another.doc", s.replaceAfterLast("/", "another.doc"))
+    assertEquals("new name.extension", s.replaceBefore(".", "new name"))
+    assertEquals("/new/path/file.extension", s.replaceBeforeLast("/", "/new/path"))
+
+    // non-existing delimiter
+    assertEquals("/user/folder/file.extension", s.replaceAfter("=", "doc"))
+    assertEquals("/user/folder/file.extension", s.replaceAfterLast("=", "another.doc"))
+    assertEquals("/user/folder/file.extension", s.replaceBefore("=", "new name"))
+    assertEquals("/user/folder/file.extension", s.replaceBeforeLast("=", "/new/path"))
+    assertEquals("xxx", s.replaceBefore("=", "new name", "xxx"))
+    assertEquals("xxx", s.replaceBeforeLast("=", "/new/path", "xxx"))
+}

backend.native/tests/external/stdlib/text/StringTest/replaceFirst.kt

@@ -0,0 +1,16 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val input = "AbbabA"
+    assertEquals("Abb${'$'}bA", input.replaceFirst('a','$'))
+    assertEquals("${'$'}bbabA", input.replaceFirst('a','$', ignoreCase = true))
+    // doesn't pass in Rhino JS
+    // assertEquals("schrodinger", "schrÖdinger".replaceFirst('ö', 'o', ignoreCase = true))
+
+    assertEquals("Abba${'$'}", input.replaceFirst("bA", "$"))
+    assertEquals("Ab${'$'}bA", input.replaceFirst("bA", "$", ignoreCase = true))
+
+    assertEquals("-test", "test".replaceFirst("", "-"))
+}

backend.native/tests/external/stdlib/text/StringTest/reverse.kt

@@ -0,0 +1,9 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    assertEquals("dcba", "abcd".reversed())
+    assertEquals("4321", "1234".reversed())
+    assertEquals("", "".reversed())
+}

backend.native/tests/external/stdlib/text/StringTest/slice.kt

@@ -0,0 +1,12 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val iter = listOf(4, 3, 0, 1)
+    // abcde
+    // 01234
+    assertEquals("bcd", "abcde".substring(1..3))
+    assertEquals("dcb", "abcde".slice(3 downTo 1))
+    assertEquals("edab", "abcde".slice(iter))
+}

backend.native/tests/external/stdlib/text/StringTest/startsWithString.kt

@@ -0,0 +1,17 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    assertTrue("abcd".startsWith("ab"))
+    assertTrue("abcd".startsWith("abcd"))
+    assertTrue("abcd".startsWith("a"))
+    assertFalse("abcd".startsWith("abcde"))
+    assertFalse("abcd".startsWith("b"))
+    assertFalse("".startsWith("a"))
+    assertTrue("some".startsWith(""))
+    assertTrue("".startsWith(""))
+
+    assertFalse("abcd".startsWith("aB", ignoreCase = false))
+    assertTrue("abcd".startsWith("aB", ignoreCase = true))
+}

backend.native/tests/external/stdlib/text/StringTest/substringDelimited.kt

@@ -0,0 +1,27 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val s = "-1,22,3+"
+    // chars
+    assertEquals("22,3+", s.substringAfter(','))
+    assertEquals("3+", s.substringAfterLast(','))
+    assertEquals("-1", s.substringBefore(','))
+    assertEquals("-1,22", s.substringBeforeLast(','))
+
+    // strings
+    assertEquals("22,3+", s.substringAfter(","))
+    assertEquals("3+", s.substringAfterLast(","))
+    assertEquals("-1", s.substringBefore(","))
+    assertEquals("-1,22", s.substringBeforeLast(","))
+
+    // non-existing delimiter
+    assertEquals("", s.substringAfter("+"))
+    assertEquals("", s.substringBefore("-"))
+    assertEquals(s, s.substringBefore("="))
+    assertEquals(s, s.substringAfter("="))
+    assertEquals("xxx", s.substringBefore("=", "xxx"))
+    assertEquals("xxx", s.substringAfter("=", "xxx"))
+
+}

backend.native/tests/external/stdlib/text/StringTest/take.kt

@@ -0,0 +1,12 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    val data = "abcd1234"
+    assertEquals("abc", data.take(3))
+    assertFails {
+        data.take(-7)
+    }
+    assertEquals(data, data.take(data.length + 42))
+}

backend.native/tests/external/stdlib/text/StringTest/takeWhile.kt

@@ -0,0 +1,13 @@
+import kotlin.test.*
+
+// helper predicates available on both platforms
+fun Char.isAsciiDigit() = this in '0'..'9'
+fun Char.isAsciiLetter() = this in 'A'..'Z' || this in 'a'..'z'
+fun Char.isAsciiUpperCase() = this in 'A'..'Z'
+
+fun box() {
+    val data = "ab1cd2"
+    assertEquals("ab", data.takeWhile { it.isAsciiLetter() })
+    assertEquals("", data.takeWhile { false })
+    assertEquals("ab1cd2", data.takeWhile { true })
+}

backend.native/tests/external/stdlib/text/StringTest/testIndent.kt

@@ -0,0 +1,11 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    assertEquals("  ABC\n  123", "ABC\n123".prependIndent("  "))
+    assertEquals("  ABC\n  \n  123", "ABC\n\n123".prependIndent("  "))
+    assertEquals("  ABC\n  \n  123", "ABC\n \n123".prependIndent("  "))
+    assertEquals("  ABC\n   \n  123", "ABC\n   \n123".prependIndent("  "))
+    assertEquals("  ", "".prependIndent("  "))
+}

backend.native/tests/external/stdlib/text/StringTest/trimIndent.kt

@@ -0,0 +1,67 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    // WARNING
+    // DO NOT REFORMAT AS TESTS MAY FAIL DUE TO INDENTATION CHANGE
+
+    assertEquals("123", """
+    123
+    """.trimIndent())
+
+    assertEquals("123\n   456", """
+    123
+       456
+       """.trimIndent())
+
+    assertEquals("   123\n456", """
+       123
+    456
+    """.trimIndent())
+
+    assertEquals("     123\n  456", """
+       123
+    456
+    """.replaceIndent(newIndent = "  "))
+
+    assertEquals("   123\n456", """
+       123
+    456""".trimIndent())
+
+    assertEquals("    ", """
+${"    "}
+    """.trimIndent())
+
+    val deindented = """
+                                                        ,.
+                  ,.                     _       oo.   `88P
+                 ]88b              ,o.  d88.    ]88b     '
+                  888   _          Y888o888     d88P     _     _
+                  888 ,888          `Y88888o_  ,888    d88b   d88._____
+                  888,888P ,oooooo.   ;888888b.]88P    888'   d888888888p
+                  888888P d88888888.  J88b'YPP ]88b   ,888    d888P'''888.
+                  8888P' ]88P   `888  d88[     d88P   ]88b    888'    Y88b
+                  8888p  ]88b    888  888      d88[    888    888.    `888
+                 ,88888b  888[   888  888.     d88[    888.   Y88b     Y88[
+                 d88PY88b `888L,d88P  Y88b     Y88b    ]88b   `888     888'
+                 888  Y88b  Y88888P    888.     888.    888.   Y88b   `88P
+                d88P   888   `'P'      Y888.    `888.   `88P   `Y8P     '
+                Y8P'    '               `YP      Y8P'     '
+
+                ____       dXp   _    _        _________
+              ddXXXXXp     XXP  ,XX  dXb      Yo.XXXXXX      ,oooooo.
+              X'L_oXXP     XX'   XX[ dXb      dXb            YPPPPXXX'
+              XYXXXXX     ]XX    dXb dXb      dX8Xooooo         dXXP
+              XXb`YYXXo.   YXXo_ dXP dXP      YXb''''''       ,XXP'
+              `XX   `YYXb   `YXXXXP  XX[      ]XX            ,XX'
+               YXb     YXb     `''   XXXXooL  `XX._____      `XXXXXXXXooooo.
+               `XP      '             ''''''   YPXXXXXX'       ''''''`''YPPP
+    """.trimIndent()
+
+    assertEquals(23, deindented.lines().size)
+    val indents = deindented.lines().map { "^\\s*".toRegex().find(it)!!.value.length }
+    assertEquals(0, indents.min())
+    assertEquals(42, indents.max())
+    assertEquals(1, deindented.lines().count { it.isEmpty() })
+}

backend.native/tests/external/stdlib/text/StringTest/trimMargin.kt

@@ -0,0 +1,50 @@
+import kotlin.test.*
+
+
+
+fun box() {
+    // WARNING
+    // DO NOT REFORMAT AS TESTS MAY FAIL DUE TO INDENTATION CHANGE
+
+    assertEquals("ABC\n123\n456", """ABC
+                                  |123
+                                  |456""".trimMargin())
+
+    assertEquals("ABC\n  123\n  456", """ABC
+                                  |123
+                                  |456""".replaceIndentByMargin(newIndent = "  "))
+
+    assertEquals("ABC \n123\n456", """ABC${" "}
+                                  |123
+                                  |456""".trimMargin())
+
+    assertEquals(" ABC\n123\n456", """ ABC
+                                    >>123
+                                    ${"\t"}>>456""".trimMargin(">>"))
+
+    assertEquals("", "".trimMargin())
+
+    assertEquals("", """
+                        """.trimMargin())
+
+    assertEquals("", """
+                        |""".trimMargin())
+
+    assertEquals("", """
+                        |
+                        """.trimMargin())
+
+    assertEquals("    a", """
+        |    a
+    """.trimMargin())
+
+    assertEquals("    a", """
+        |    a""".trimMargin())
+
+    assertEquals("    a", """ |    a
+    """.trimMargin())
+
+    assertEquals("    a", """ |    a""".trimMargin())
+
+    assertEquals("\u0000|ABC", "${"\u0000"}|ABC".trimMargin())
+}