From 8c16fad8b13e4168f4a9f8c108e9fe691704861f Mon Sep 17 00:00:00 2001 From: Ilya Gorbunov Date: Tue, 27 Oct 2015 21:44:29 +0300 Subject: [PATCH] Make more string tests cross-platform. --- libraries/stdlib/test/text/StringJVMTest.kt | 308 +------------------- libraries/stdlib/test/text/StringTest.kt | 303 +++++++++++++++++++ 2 files changed, 306 insertions(+), 305 deletions(-) diff --git a/libraries/stdlib/test/text/StringJVMTest.kt b/libraries/stdlib/test/text/StringJVMTest.kt index 6e26d8c27bd..5e248301af0 100644 --- a/libraries/stdlib/test/text/StringJVMTest.kt +++ b/libraries/stdlib/test/text/StringJVMTest.kt @@ -7,14 +7,6 @@ import org.junit.Test as test class StringJVMTest { - @test fun orEmpty() { - val s: String? = "hey" - val ns: String? = null - - assertEquals("hey", s.orEmpty()) - assertEquals("", ns.orEmpty()) - } - @test fun toBoolean() { assertEquals(true, "true".toBoolean()) assertEquals(true, "True".toBoolean()) @@ -39,24 +31,6 @@ class StringJVMTest { assertEquals(77.toLong(), "77".toLong()) } - @test fun count() = withOneCharSequenceArg("hello there\tfoo\nbar") { text -> - val whitespaceCount = text.count { it.isWhitespace() } - assertEquals(3, whitespaceCount) - } - - @test fun testSplitByChar() = withOneCharSequenceArg("ab\n[|^$&\\]^cd") { s -> - var list = s.split('b'); - assertEquals(2, list.size()) - assertEquals("a", list[0]) - assertEquals("\n[|^$&\\]^cd", list[1]) - list = s.split('^') - assertEquals(3, list.size()) - assertEquals("cd", list[2]) - list = s.split('.') - assertEquals(1, list.size()) - assertEquals(s.toString(), list[0]) - } - @test fun testSplitByPattern() = withOneCharSequenceArg("ab1cd2def3") { s -> val isDigit = "\\d".toRegex() assertEquals(listOf("ab", "cd", "def", ""), s.split(isDigit)) @@ -80,242 +54,14 @@ class StringJVMTest { assertEquals("foofoofoo", "foo".repeat(3)) } - @test fun filter() = withOneCharSequenceArg { arg1 -> - assertEquals("acdca", arg1("abcdcba").filter { !it.equals('b') }) - assertEquals("1234", arg1("a1b2c3d4").filter { it.isDigit() }) - } - @test fun filterNot() = withOneCharSequenceArg { arg1 -> - assertEquals("acdca", arg1("abcdcba").filterNot { it.equals('b') }) - assertEquals("abcd", arg1("a1b2c3d4").filterNot { it.isDigit() }) - } - - @test fun forEach() = withOneCharSequenceArg("abcd1234") { data -> - var count = 0 - val sb = StringBuilder() - data.forEach { - count++ - sb.append(it) - } - assertEquals(data.length, count) - assertEquals(data.toString(), sb.toString()) - } - - @test fun all() = withOneCharSequenceArg("AbCd") { data -> - assertTrue { - data.all { it.isJavaIdentifierPart() } - } - assertFalse { - data.all { it.isUpperCase() } - } - } - - @test fun any() = withOneCharSequenceArg("a1bc") { data -> - assertTrue { - data.any() { it.isDigit() } - } - assertFalse { - data.any() { it.isUpperCase() } - } - } - - @test fun joinTo() { - val data = "kotlin".toList() - val sb = StringBuilder() - data.joinTo(sb, "^", "<", ">") - assertEquals("", sb.toString()) - } - - @test fun find() = withOneCharSequenceArg("a1b2c3") { data -> - assertEquals('1', data.first { it.isDigit() }) - assertNull(data.firstOrNull { it.isUpperCase() }) - } - - @test fun findNot() = withOneCharSequenceArg("1a2b3c") { data -> - assertEquals('a', data.filterNot { it.isDigit() }.firstOrNull()) - assertNull(data.filterNot { it.isJavaIdentifierPart() }.firstOrNull()) - } - - @test fun partition() = withOneCharSequenceArg("a1b2c3") { data -> - val pair = data.partition { it.isDigit() } - assertEquals("123", pair.first, "pair.first") - assertEquals("abc", pair.second, "pair.second") - } - - @test fun map() = withOneCharSequenceArg { arg1 -> - assertEquals(listOf('a', 'b', 'c'), arg1("abc").map { it }) - - assertEquals(listOf(true, false, true), arg1("AbC").map { it.isUpperCase() }) - - assertEquals(listOf(), arg1("").map { it.isUpperCase() }) - - assertEquals(listOf(97, 98, 99), arg1("abc").map { it.toInt() }) - } - - @test fun mapTo() = withOneCharSequenceArg { arg1 -> - val result1 = arrayListOf() - val return1 = arg1("abc").mapTo(result1, { it }) - assertEquals(result1, return1) - assertEquals(arrayListOf('a', 'b', 'c'), result1) - - val result2 = arrayListOf() - val return2 = arg1("AbC").mapTo(result2, { it.isUpperCase() }) - assertEquals(result2, return2) - assertEquals(arrayListOf(true, false, true), result2) - - val result3 = arrayListOf() - val return3 = arg1("").mapTo(result3, { it.isUpperCase() }) - assertEquals(result3, return3) - assertEquals(arrayListOf(), result3) - - val result4 = arrayListOf() - val return4 = arg1("abc").mapTo(result4, { it.toInt() }) - assertEquals(result4, return4) - assertEquals(arrayListOf(97, 98, 99), result4) - } - - @test fun flatMap() = withOneCharSequenceArg("abcd") { data -> - val result = data.flatMap { ('a'..it) + ' ' } - assertEquals("a ab abc abcd ".toCharList(), result) - } - - @test fun fold() = withOneCharSequenceArg { arg1 -> - // calculate number of digits in the string - val data = arg1("a1b2c3def") - val result = data.fold(0, { digits, c -> if(c.isDigit()) digits + 1 else digits } ) - assertEquals(3, result) - - //simulate all method - assertEquals(true, arg1("ABCD").fold(true, { r, c -> r && c.isUpperCase() })) - - //get string back - assertEquals(data.toString(), data.fold("", { s, c -> s + c })) - } - - @test fun foldRight() = withOneCharSequenceArg { arg1 -> - // calculate number of digits in the string - val data = arg1("a1b2c3def") - val result = data.foldRight(0, { c, digits -> if(c.isDigit()) digits + 1 else digits }) - assertEquals(3, result) - - //simulate all method - assertEquals(true, arg1("ABCD").foldRight(true, { c, r -> r && c.isUpperCase() })) - - //get string back - assertEquals(data.toString(), data.foldRight("", { s, c -> "" + s + c })) - } - - @test fun reduce() = withOneCharSequenceArg { arg1 -> - // get the smallest character(by char value) - assertEquals('a', arg1("bacfd").reduce { v, c -> if (v > c) c else v }) - - assertFailsWith(UnsupportedOperationException::class) { - arg1("").reduce { a, b -> '\n' } - } - } - - @test fun reduceRight() = withOneCharSequenceArg { arg1 -> - // get the smallest character(by char value) - assertEquals('a', arg1("bacfd").reduceRight { c, v -> if (v > c) c else v }) - - assertFailsWith(UnsupportedOperationException::class) { - arg1("").reduceRight { a, b -> '\n' } - } - } - - @test fun groupBy() = withOneCharSequenceArg("abAbaABcD") { data -> - // group characters by their case - val result = data.groupBy { it.isLowerCase() } - assertEquals(2, result.size) - assertEquals(listOf('a','b','b','a','c'), result[true]) - assertEquals(listOf('A','A','B','D'), result[false]) - } - - @test fun joinToString() { - 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) - } - - @test fun join() { - val data = "abcd".map { it.toString() } - val result = data.joinToString("_", "(", ")") - assertEquals("(a_b_c_d)", result) - - val data2 = "verylongstring".map { it.toString() } - val result2 = data2.joinToString("-", "[", "]", 11, "oops") - assertEquals("[v-e-r-y-l-o-n-g-s-t-r-oops]", result2) - } - - - - @test fun dropWhile() { - val data = "ab1cd2" - assertEquals("1cd2", data.dropWhile { it.isJavaIdentifierStart() }) - assertEquals("", data.dropWhile { true }) - assertEquals("ab1cd2", data.dropWhile { false }) - } - - @test fun dropWhileCharSequence() = withOneCharSequenceArg("ab1cd2") { data -> - assertContentEquals("1cd2", data.dropWhile { it.isJavaIdentifierStart() }) - assertContentEquals("", data.dropWhile { true }) - assertContentEquals("ab1cd2", data.dropWhile { false }) - } - - - @test fun drop() { - val data = "abcd1234" - assertEquals("d1234", data.drop(3)) + @test fun sliceCharSequenceFails() = withOneCharSequenceArg { arg1 -> assertFails { - data.drop(-2) + arg1("abc").slice(1..4) } - assertEquals("", data.drop(data.length() + 5)) - } - - @test fun dropCharSequence() = withOneCharSequenceArg("abcd1234") { data -> - assertContentEquals("d1234", data.drop(3)) assertFails { - data.drop(-2) + arg1("ABCDabcd").slice(listOf(10)) } - assertContentEquals("", data.drop(data.length() + 5)) - } - - @test fun takeWhile() { - val data = "ab1cd2" - assertEquals("ab", data.takeWhile { it.isJavaIdentifierStart() }) - assertEquals("", data.takeWhile { false }) - assertEquals("ab1cd2", data.takeWhile { true }) - } - - @test fun takeWhileCharSequence() = withOneCharSequenceArg("ab1cd2") { data -> - assertContentEquals("ab", data.takeWhile { it.isJavaIdentifierStart() }) - assertContentEquals("", data.takeWhile { false }) - assertContentEquals("ab1cd2", data.takeWhile { true }) - } - - @test fun take() { - val data = "abcd1234" - assertEquals("abc", data.take(3)) - assertFails { - data.take(-7) - } - assertEquals(data, data.take(data.length() + 42)) - } - - @test fun takeCharSequence() = withOneCharSequenceArg("abcd1234") { data -> - assertEquals("abc", data.take(3)) - assertFails { - data.take(-7) - } - assertContentEquals(data.toString(), data.take(data.length + 42)) } @test fun formatter() { @@ -333,54 +79,6 @@ class StringJVMTest { assertEquals(String(s.toByteArray()), String(s.toByteArray(defaultCharset.name()))) } - @test fun testReplaceAllClosure() = withOneCharSequenceArg("test123zzz") { s -> - val result = s.replace("\\d+".toRegex()) { mr -> - "[" + mr.value + "]" - } - assertEquals("test[123]zzz", result) - } - - @test fun testReplaceAllClosureAtStart() = withOneCharSequenceArg("123zzz") { s -> - val result = s.replace("\\d+".toRegex()) { mr -> - "[" + mr.value + "]" - } - assertEquals("[123]zzz", result) - } - - @test fun testReplaceAllClosureAtEnd() = withOneCharSequenceArg("test123") { s -> - val result = s.replace("\\d+".toRegex()) { mr -> - "[" + mr.value + "]" - } - assertEquals("test[123]", result) - } - - @test fun testReplaceAllClosureEmpty() = withOneCharSequenceArg("") { s -> - val result = s.replace("\\d+".toRegex()) { mr -> - "x" - } - assertEquals("", result) - - } - - @test fun slice() = withOneCharSequenceArg { arg1 -> - val iter = listOf(4, 3, 0, 1) - - val data = arg1("ABCDabcd") - // ABCDabcd - // 01234567 - assertEquals("BCDabc", data.slice(1..6).toString()) - assertEquals("baD", data.slice(5 downTo 3).toString()) - assertEquals("aDAB", data.slice(iter).toString()) - - assertFails { - arg1("abc").slice(listOf(1,4)) - } - assertFails { - data.slice(listOf(10)) - } - } - - @test fun orderIgnoringCase() { val list = listOf("Beast", "Ast", "asterisk") assertEquals(listOf("Ast", "Beast", "asterisk"), list.sorted()) diff --git a/libraries/stdlib/test/text/StringTest.kt b/libraries/stdlib/test/text/StringTest.kt index 2ca9f5ac071..a1b6c044f11 100644 --- a/libraries/stdlib/test/text/StringTest.kt +++ b/libraries/stdlib/test/text/StringTest.kt @@ -29,6 +29,11 @@ fun assertContentEquals(expected: String, actual: CharSequence) { assertEquals(expected, actual.toString()) } +// 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' + class StringTest { @test fun isEmptyAndBlank() = withOneCharSequenceArg { arg1 -> @@ -52,6 +57,14 @@ class StringTest { } } + @test fun orEmpty() { + val s: String? = "hey" + val ns: String? = null + + assertEquals("hey", s.orEmpty()) + assertEquals("", ns.orEmpty()) + } + @test fun startsWithString() { assertTrue("abcd".startsWith("ab")) assertTrue("abcd".startsWith("abcd")) @@ -192,6 +205,17 @@ class StringTest { assertEquals("edab", "abcde".slice(iter)) } + @test fun sliceCharSequence() = withOneCharSequenceArg { arg1 -> + val iter = listOf(4, 3, 0, 1) + + val data = arg1("ABCDabcd") + // ABCDabcd + // 01234567 + assertEquals("BCDabc", data.slice(1..6).toString()) + assertEquals("baD", data.slice(5 downTo 3).toString()) + assertEquals("aDAB", data.slice(iter).toString()) + } + @test fun reverse() = withOneCharSequenceArg { arg1 -> fun String.reversed(): String = arg1(this).reversed() @@ -628,6 +652,285 @@ class StringTest { assertEquals("-test", "test".replaceFirst("", "-")) } + @test fun count() = withOneCharSequenceArg("hello there\tfoo\nbar") { text -> + val whitespaceCount = text.count { it.isWhitespace() } + assertEquals(3, whitespaceCount) + } + + @test fun testSplitByChar() = withOneCharSequenceArg("ab\n[|^$&\\]^cd") { s -> + s.split('b').let { list -> + assertEquals(2, list.size) + assertEquals("a", list[0]) + assertEquals("\n[|^$&\\]^cd", list[1]) + } + s.split('^').let { list -> + assertEquals(3, list.size) + assertEquals("cd", list[2]) + } + s.split('.').let { list -> + assertEquals(1, list.size) + assertEquals(s.toString(), list[0]) + } + } + + @test fun forEach() = withOneCharSequenceArg("abcd1234") { data -> + var count = 0 + val sb = StringBuilder() + data.forEach { + count++ + sb.append(it) + } + assertEquals(data.length, count) + assertEquals(data.toString(), sb.toString()) + } + + + @test fun filter() = withOneCharSequenceArg { arg1 -> + assertEquals("acdca", arg1("abcdcba").filter { !it.equals('b') }) + assertEquals("1234", arg1("a1b2c3d4").filter { it.isAsciiDigit() }) + } + + @test fun filterNot() = withOneCharSequenceArg { arg1 -> + assertEquals("acdca", arg1("abcdcba").filterNot { it.equals('b') }) + assertEquals("abcd", arg1("a1b2c3d4").filterNot { it.isAsciiDigit() }) + } + + @test fun all() = withOneCharSequenceArg("AbCd") { data -> + assertTrue { + data.all { it.isAsciiLetter() } + } + assertFalse { + data.all { it.isAsciiUpperCase() } + } + } + + @test fun any() = withOneCharSequenceArg("a1bc") { data -> + assertTrue { + data.any() { it.isAsciiDigit() } + } + assertFalse { + data.any() { it.isAsciiUpperCase() } + } + } + + @test fun find() = withOneCharSequenceArg("a1b2c3") { data -> + assertEquals('1', data.first { it.isAsciiDigit() }) + assertNull(data.firstOrNull { it.isAsciiUpperCase() }) + } + + @test fun findNot() = withOneCharSequenceArg("1a2b3c") { data -> + assertEquals('a', data.filterNot { it.isAsciiDigit() }.firstOrNull()) + assertNull(data.filterNot { it.isAsciiLetter() || it.isAsciiDigit() }.firstOrNull()) + } + + @test fun partition() = withOneCharSequenceArg("a1b2c3") { data -> + val pair = data.partition { it.isAsciiDigit() } + assertEquals("123", pair.first, "pair.first") + assertEquals("abc", pair.second, "pair.second") + } + + @test fun map() = withOneCharSequenceArg { arg1 -> + assertEquals(listOf('a', 'b', 'c'), arg1("abc").map { it }) + + assertEquals(listOf(true, false, true), arg1("AbC").map { it.isAsciiUpperCase() }) + + assertEquals(listOf(), arg1("").map { it.isAsciiUpperCase() }) + + assertEquals(listOf(97, 98, 99), arg1("abc").map { it.toInt() }) + } + + @test fun mapTo() = withOneCharSequenceArg { arg1 -> + val result1 = arrayListOf() + val return1 = arg1("abc").mapTo(result1, { it }) + assertEquals(result1, return1) + assertEquals(arrayListOf('a', 'b', 'c'), result1) + + val result2 = arrayListOf() + val return2 = arg1("AbC").mapTo(result2, { it.isAsciiUpperCase() }) + assertEquals(result2, return2) + assertEquals(arrayListOf(true, false, true), result2) + + val result3 = arrayListOf() + val return3 = arg1("").mapTo(result3, { it.isAsciiUpperCase() }) + assertEquals(result3, return3) + assertEquals(arrayListOf(), result3) + + val result4 = arrayListOf() + val return4 = arg1("abc").mapTo(result4, { it.toInt() }) + assertEquals(result4, return4) + assertEquals(arrayListOf(97, 98, 99), result4) + } + + @test fun flatMap() = withOneCharSequenceArg("abcd") { data -> + val result = data.flatMap { ('a'..it) + ' ' } + assertEquals("a ab abc abcd ".toList(), result) + } + + @test fun fold() = withOneCharSequenceArg { arg1 -> + // calculate number of digits in the string + val data = arg1("a1b2c3def") + val result = data.fold(0, { digits, c -> if(c.isAsciiDigit()) digits + 1 else digits } ) + assertEquals(3, result) + + //simulate all method + assertEquals(true, arg1("ABCD").fold(true, { r, c -> r && c.isAsciiUpperCase() })) + + //get string back + assertEquals(data.toString(), data.fold("", { s, c -> s + c })) + } + + @test fun foldRight() = withOneCharSequenceArg { arg1 -> + // calculate number of digits in the string + val data = arg1("a1b2c3def") + val result = data.foldRight(0, { c, digits -> if(c.isAsciiDigit()) digits + 1 else digits }) + assertEquals(3, result) + + //simulate all method + assertEquals(true, arg1("ABCD").foldRight(true, { c, r -> r && c.isAsciiUpperCase() })) + + //get string back + assertEquals(data.toString(), data.foldRight("", { s, c -> "" + s + c })) + } + + @test fun reduce() = withOneCharSequenceArg { arg1 -> + // get the smallest character(by char value) + assertEquals('a', arg1("bacfd").reduce { v, c -> if (v > c) c else v }) + + assertTrue(assertFails { + arg1("").reduce { a, b -> '\n' } + } is UnsupportedOperationException) + } + + @test fun reduceRight() = withOneCharSequenceArg { arg1 -> + // get the smallest character(by char value) + assertEquals('a', arg1("bacfd").reduceRight { c, v -> if (v > c) c else v }) + + assertTrue(assertFails { + arg1("").reduceRight { a, b -> '\n' } + } is UnsupportedOperationException) + } + + @test fun groupBy() = withOneCharSequenceArg("abAbaABcD") { data -> + // group characters by their case + val result = data.groupBy { it.isAsciiUpperCase() } + assertEquals(2, result.size) + assertEquals(listOf('a','b','b','a','c'), result[false]) + assertEquals(listOf('A','A','B','D'), result[true]) + } + + @test fun joinToString() { + 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) + } + + @test fun joinTo() { + val data = "kotlin".toList() + val sb = StringBuilder() + data.joinTo(sb, "^", "<", ">") + assertEquals("", sb.toString()) + } + + + @test fun dropWhile() { + val data = "ab1cd2" + assertEquals("1cd2", data.dropWhile { it.isAsciiLetter() }) + assertEquals("", data.dropWhile { true }) + assertEquals("ab1cd2", data.dropWhile { false }) + } + + @test fun dropWhileCharSequence() = withOneCharSequenceArg("ab1cd2") { data -> + assertContentEquals("1cd2", data.dropWhile { it.isAsciiLetter() }) + assertContentEquals("", data.dropWhile { true }) + assertContentEquals("ab1cd2", data.dropWhile { false }) + } + + + @test fun drop() { + val data = "abcd1234" + assertEquals("d1234", data.drop(3)) + assertFails { + data.drop(-2) + } + assertEquals("", data.drop(data.length() + 5)) + } + + @test fun dropCharSequence() = withOneCharSequenceArg("abcd1234") { data -> + assertContentEquals("d1234", data.drop(3)) + assertFails { + data.drop(-2) + } + assertContentEquals("", data.drop(data.length() + 5)) + } + + @test fun takeWhile() { + val data = "ab1cd2" + assertEquals("ab", data.takeWhile { it.isAsciiLetter() }) + assertEquals("", data.takeWhile { false }) + assertEquals("ab1cd2", data.takeWhile { true }) + } + + @test fun takeWhileCharSequence() = withOneCharSequenceArg("ab1cd2") { data -> + assertContentEquals("ab", data.takeWhile { it.isAsciiLetter() }) + assertContentEquals("", data.takeWhile { false }) + assertContentEquals("ab1cd2", data.takeWhile { true }) + } + + @test fun take() { + val data = "abcd1234" + assertEquals("abc", data.take(3)) + assertFails { + data.take(-7) + } + assertEquals(data, data.take(data.length() + 42)) + } + + @test fun takeCharSequence() = withOneCharSequenceArg("abcd1234") { data -> + assertEquals("abc", data.take(3)) + assertFails { + data.take(-7) + } + assertContentEquals(data.toString(), data.take(data.length + 42)) + } + + + @test fun testReplaceAllClosure() = withOneCharSequenceArg("test123zzz") { s -> + val result = s.replace("\\d+".toRegex()) { mr -> + "[" + mr.value + "]" + } + assertEquals("test[123]zzz", result) + } + + @test fun testReplaceAllClosureAtStart() = withOneCharSequenceArg("123zzz") { s -> + val result = s.replace("\\d+".toRegex()) { mr -> + "[" + mr.value + "]" + } + assertEquals("[123]zzz", result) + } + + @test fun testReplaceAllClosureAtEnd() = withOneCharSequenceArg("test123") { s -> + val result = s.replace("\\d+".toRegex()) { mr -> + "[" + mr.value + "]" + } + assertEquals("test[123]", result) + } + + @test fun testReplaceAllClosureEmpty() = withOneCharSequenceArg("") { s -> + val result = s.replace("\\d+".toRegex()) { mr -> + "x" + } + assertEquals("", result) + + } + @test fun trimMargin() { // WARNING // DO NOT REFORMAT AS TESTS MAY FAIL DUE TO INDENTATION CHANGE