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/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())
+}