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

Minor: normalize '@Test' annotation casing in all tests.

Browse Source
This commit is contained in:
Ilya Gorbunov
2016-11-16 21:26:39 +03:00
parent 50cd620f92
commit 6a70761783
48 changed files with 749 additions and 751 deletions
Download Patch File Download Diff File Expand all files Collapse all files
generators/src/org/jetbrains/kotlin/generators/tests/GenerateRangesCodegenTestData.java
+1 -1
View File
@@ -40,7 +40,7 @@ public class GenerateRangesCodegenTestData {
new File("libraries/stdlib/test/ranges/RangeIterationJVMTest.kt")
};
private static final Pattern TEST_FUN_PATTERN = Pattern.compile("test fun (\\w+)\\(\\) \\{.+?}", Pattern.DOTALL);
private static final Pattern TEST_FUN_PATTERN = Pattern.compile("@Test fun (\\w+)\\(\\) \\{.+?}", Pattern.DOTALL);
private static final Pattern SUBTEST_INVOCATION_PATTERN = Pattern.compile("doTest\\(([^,]+), [^,]+, [^,]+, [^,]+,\\s+listOf[\\w<>]*\\(([^\\n]*)\\)\\)", Pattern.DOTALL);
// $LIST.size() check is needed in order for tests not to run forever
libraries/stdlib/test/ExceptionJVMTest.kt
+4 -4
View File
@@ -4,19 +4,19 @@ package test.exceptions
import kotlin.test.*
import test.collections.assertArrayNotSameButEquals
import org.junit.Test as test
import org.junit.Test
import java.io.PrintWriter
import java.io.*
import java.nio.charset.Charset
class ExceptionJVMTest {
@test fun printStackTraceOnRuntimeException() {
@Test fun printStackTraceOnRuntimeException() {
assertPrintStackTrace(RuntimeException("Crikey!"))
assertPrintStackTraceStream(RuntimeException("Crikey2"))
}
@test fun printStackTraceOnError() {
@Test fun printStackTraceOnError() {
assertPrintStackTrace(Error("Oh dear"))
assertPrintStackTraceStream(Error("Oh dear2"))
}
@@ -55,7 +55,7 @@ class ExceptionJVMTest {
}
}
@test fun changeStackTrace() {
@Test fun changeStackTrace() {
val exception = RuntimeException("Fail")
var stackTrace = exception.stackTrace
stackTrace = stackTrace.dropLast(1).toTypedArray()
libraries/stdlib/test/TuplesTest.kt
+15 -15
View File
@@ -1,6 +1,6 @@
package test.tuples
import org.junit.Test as test
import org.junit.Test
import kotlin.test.assertTrue
import kotlin.test.assertEquals
import kotlin.test.assertNotEquals
@@ -8,22 +8,22 @@ import kotlin.test.assertNotEquals
class PairTest {
val p = Pair(1, "a")
@test fun pairFirstAndSecond() {
@Test fun pairFirstAndSecond() {
assertEquals(1, p.first)
assertEquals("a", p.second)
}
@test fun pairMultiAssignment() {
@Test fun pairMultiAssignment() {
val (a, b) = p
assertEquals(1, a)
assertEquals("a", b)
}
@test fun pairToString() {
@Test fun pairToString() {
assertEquals("(1, a)", p.toString())
}
@test fun pairEquals() {
@Test fun pairEquals() {
assertEquals(Pair(1, "a"), p)
assertNotEquals(Pair(2, "a"), p)
assertNotEquals(Pair(1, "b"), p)
@@ -31,7 +31,7 @@ class PairTest {
assertNotEquals("", (p as Any))
}
@test fun pairHashCode() {
@Test fun pairHashCode() {
assertEquals(Pair(1, "a").hashCode(), p.hashCode())
assertNotEquals(Pair(2, "a").hashCode(), p.hashCode())
assertNotEquals(0, Pair(null, "b").hashCode())
@@ -39,13 +39,13 @@ class PairTest {
assertEquals(0, Pair(null, null).hashCode())
}
@test fun pairHashSet() {
@Test fun pairHashSet() {
val s = hashSetOf(Pair(1, "a"), Pair(1, "b"), Pair(1, "a"))
assertEquals(2, s.size)
assertTrue(s.contains(p))
}
@test fun pairToList() {
@Test fun pairToList() {
assertEquals(listOf(1, 2), (1 to 2).toList())
assertEquals(listOf(1, null), (1 to null).toList())
assertEquals(listOf(1, "2"), (1 to "2").toList())
@@ -55,24 +55,24 @@ class PairTest {
class TripleTest {
val t = Triple(1, "a", 0.07)
@test fun tripleFirstAndSecond() {
@Test fun tripleFirstAndSecond() {
assertEquals(1, t.first)
assertEquals("a", t.second)
assertEquals(0.07, t.third)
}
@test fun tripleMultiAssignment() {
@Test fun tripleMultiAssignment() {
val (a, b, c) = t
assertEquals(1, a)
assertEquals("a", b)
assertEquals(0.07, c)
}
@test fun tripleToString() {
@Test fun tripleToString() {
assertEquals("(1, a, 0.07)", t.toString())
}
@test fun tripleEquals() {
@Test fun tripleEquals() {
assertEquals(Triple(1, "a", 0.07), t)
assertNotEquals(Triple(2, "a", 0.07), t)
assertNotEquals(Triple(1, "b", 0.07), t)
@@ -81,7 +81,7 @@ class TripleTest {
assertNotEquals("", (t as Any))
}
@test fun tripleHashCode() {
@Test fun tripleHashCode() {
assertEquals(Triple(1, "a", 0.07).hashCode(), t.hashCode())
assertNotEquals(Triple(2, "a", 0.07).hashCode(), t.hashCode())
assertNotEquals(0, Triple(null, "b", 0.07).hashCode())
@@ -90,13 +90,13 @@ class TripleTest {
assertEquals(0, Triple(null, null, null).hashCode())
}
@test fun tripleHashSet() {
@Test fun tripleHashSet() {
val s = hashSetOf(Triple(1, "a", 0.07), Triple(1, "b", 0.07), Triple(1, "a", 0.07))
assertEquals(2, s.size)
assertTrue(s.contains(t))
}
@test fun tripleToList() {
@Test fun tripleToList() {
assertEquals(listOf(1, 2, 3), (Triple(1, 2, 3)).toList())
assertEquals(listOf(1, null, 3), (Triple(1, null, 3)).toList())
assertEquals(listOf(1, 2, "3"), (Triple(1, 2, "3")).toList())
libraries/stdlib/test/collections/ArraysTest.kt
+100 -100
View File
@@ -19,7 +19,7 @@ package test.collections
import test.collections.behaviors.listBehavior
import test.comparisons.STRING_CASE_INSENSITIVE_ORDER
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
import kotlin.comparisons.*
fun <T> assertArrayNotSameButEquals(expected: Array<out T>, actual: Array<out T>, message: String = "") { assertTrue(expected !== actual && expected contentEquals actual, message) }
@@ -39,7 +39,7 @@ class ArraysTest {
override fun hashCode(): Int = value
}
@test fun orEmptyNull() {
@Test fun orEmptyNull() {
val x: Array<String>? = null
val y: Array<out String>? = null
val xArray = x.orEmpty()
@@ -48,7 +48,7 @@ class ArraysTest {
expect(0) { yArray.size }
}
@test fun orEmptyNotNull() {
@Test fun orEmptyNotNull() {
val x: Array<String>? = arrayOf("1", "2")
val xArray = x.orEmpty()
expect(2) { xArray.size }
@@ -56,7 +56,7 @@ class ArraysTest {
expect("2") { xArray[1] }
}
@test fun emptyArrayLastIndex() {
@Test fun emptyArrayLastIndex() {
val arr1 = IntArray(0)
assertEquals(-1, arr1.lastIndex)
@@ -64,7 +64,7 @@ class ArraysTest {
assertEquals(-1, arr2.lastIndex)
}
@test fun arrayLastIndex() {
@Test fun arrayLastIndex() {
val arr1 = intArrayOf(0, 1, 2, 3, 4)
assertEquals(4, arr1.lastIndex)
assertEquals(4, arr1[arr1.lastIndex])
@@ -74,7 +74,7 @@ class ArraysTest {
assertEquals("4", arr2[arr2.lastIndex])
}
@test fun byteArray() {
@Test fun byteArray() {
val arr = ByteArray(2)
val expected: Byte = 0
@@ -83,7 +83,7 @@ class ArraysTest {
assertEquals(expected, arr[1])
}
@test fun byteArrayInit() {
@Test fun byteArrayInit() {
val arr = ByteArray(2) { it.toByte() }
assertEquals(2, arr.size)
@@ -91,7 +91,7 @@ class ArraysTest {
assertEquals(1.toByte(), arr[1])
}
@test fun shortArray() {
@Test fun shortArray() {
val arr = ShortArray(2)
val expected: Short = 0
@@ -100,7 +100,7 @@ class ArraysTest {
assertEquals(expected, arr[1])
}
@test fun shortArrayInit() {
@Test fun shortArrayInit() {
val arr = ShortArray(2) { it.toShort() }
assertEquals(2, arr.size)
@@ -108,7 +108,7 @@ class ArraysTest {
assertEquals(1.toShort(), arr[1])
}
@test fun intArray() {
@Test fun intArray() {
val arr = IntArray(2)
assertEquals(arr.size, 2)
@@ -116,7 +116,7 @@ class ArraysTest {
assertEquals(0, arr[1])
}
@test fun intArrayInit() {
@Test fun intArrayInit() {
val arr = IntArray(2) { it.toInt() }
assertEquals(2, arr.size)
@@ -124,7 +124,7 @@ class ArraysTest {
assertEquals(1.toInt(), arr[1])
}
@test fun longArray() {
@Test fun longArray() {
val arr = LongArray(2)
val expected: Long = 0
@@ -133,7 +133,7 @@ class ArraysTest {
assertEquals(expected, arr[1])
}
@test fun longArrayInit() {
@Test fun longArrayInit() {
val arr = LongArray(2) { it.toLong() }
assertEquals(2, arr.size)
@@ -141,7 +141,7 @@ class ArraysTest {
assertEquals(1.toLong(), arr[1])
}
@test fun floatArray() {
@Test fun floatArray() {
val arr = FloatArray(2)
val expected: Float = 0.0F
@@ -150,7 +150,7 @@ class ArraysTest {
assertEquals(expected, arr[1])
}
@test fun floatArrayInit() {
@Test fun floatArrayInit() {
val arr = FloatArray(2) { it.toFloat() }
assertEquals(2, arr.size)
@@ -158,7 +158,7 @@ class ArraysTest {
assertEquals(1.toFloat(), arr[1])
}
@test fun doubleArray() {
@Test fun doubleArray() {
val arr = DoubleArray(2)
assertEquals(arr.size, 2)
@@ -166,7 +166,7 @@ class ArraysTest {
assertEquals(0.0, arr[1])
}
@test fun doubleArrayInit() {
@Test fun doubleArrayInit() {
val arr = DoubleArray(2) { it.toDouble() }
assertEquals(2, arr.size)
@@ -174,7 +174,7 @@ class ArraysTest {
assertEquals(1.toDouble(), arr[1])
}
@test fun charArray() {
@Test fun charArray() {
val arr = CharArray(2)
val expected: Char = '\u0000'
@@ -183,7 +183,7 @@ class ArraysTest {
assertEquals(expected, arr[1])
}
@test fun charArrayInit() {
@Test fun charArrayInit() {
val arr = CharArray(2) { 'a' + it }
assertEquals(2, arr.size)
@@ -191,14 +191,14 @@ class ArraysTest {
assertEquals('b', arr[1])
}
@test fun booleanArray() {
@Test fun booleanArray() {
val arr = BooleanArray(2)
assertEquals(arr.size, 2)
assertEquals(false, arr[0])
assertEquals(false, arr[1])
}
@test fun booleanArrayInit() {
@Test fun booleanArrayInit() {
val arr = BooleanArray(2) { it % 2 == 0 }
assertEquals(2, arr.size)
@@ -206,7 +206,7 @@ class ArraysTest {
assertEquals(false, arr[1])
}
@test fun contentEquals() {
@Test fun contentEquals() {
val arr1 = arrayOf("a", 1, null)
val arr2 = arrayOf(*arr1)
assertTrue(arr1 contentEquals arr2)
@@ -214,7 +214,7 @@ class ArraysTest {
assertFalse(arr1 contentEquals arr3)
}
@test fun contentDeepEquals() {
@Test fun contentDeepEquals() {
val arr1 = arrayOf("a", 1, intArrayOf(2))
val arr2 = arrayOf("a", 1, intArrayOf(2))
assertFalse(arr1 contentEquals arr2)
@@ -223,17 +223,17 @@ class ArraysTest {
assertFalse(arr1 contentDeepEquals arr2)
}
@test fun contentToString() {
@Test fun contentToString() {
val arr = arrayOf("a", 1, null)
assertEquals(arr.asList().toString(), arr.contentToString())
}
@test fun contentDeepToString() {
@Test fun contentDeepToString() {
val arr = arrayOf("aa", 1, null, charArrayOf('d'))
assertEquals("[aa, 1, null, [d]]", arr.contentDeepToString())
}
@test fun contentDeepToStringNoRecursion() {
@Test fun contentDeepToStringNoRecursion() {
// a[b[a, b]]
val b = arrayOfNulls<Any>(2)
val a = arrayOf(b)
@@ -247,19 +247,19 @@ class ArraysTest {
assertEquals("[[[...], [...]]]", result)
}
@test fun contentHashCode() {
@Test fun contentHashCode() {
val arr = arrayOf("a", 1, null, Value(5))
assertEquals(listOf(*arr).hashCode(), arr.contentHashCode())
assertEquals((1*31 + 2)*31 + 3, arrayOf(Value(2), Value(3)).contentHashCode())
}
@test fun contentDeepHashCode() {
@Test fun contentDeepHashCode() {
val arr = arrayOf(null, Value(2), arrayOf(Value(3)))
assertEquals(((1*31 + 0)*31 + 2) * 31 + (1 * 31 + 3), arr.contentDeepHashCode())
}
@test fun min() {
@Test fun min() {
expect(null, { arrayOf<Int>().min() })
expect(1, { arrayOf(1).min() })
expect(2, { arrayOf(2, 3).min() })
@@ -268,7 +268,7 @@ class ArraysTest {
expect("a", { arrayOf("a", "b").min() })
}
@test fun minInPrimitiveArrays() {
@Test fun minInPrimitiveArrays() {
expect(null, { intArrayOf().min() })
expect(1, { intArrayOf(1).min() })
expect(2, { intArrayOf(2, 3).min() })
@@ -280,7 +280,7 @@ class ArraysTest {
expect('a', { charArrayOf('a', 'b').min() })
}
@test fun max() {
@Test fun max() {
expect(null, { arrayOf<Int>().max() })
expect(1, { arrayOf(1).max() })
expect(3, { arrayOf(2, 3).max() })
@@ -289,7 +289,7 @@ class ArraysTest {
expect("b", { arrayOf("a", "b").max() })
}
@test fun maxInPrimitiveArrays() {
@Test fun maxInPrimitiveArrays() {
expect(null, { intArrayOf().max() })
expect(1, { intArrayOf(1).max() })
expect(3, { intArrayOf(2, 3).max() })
@@ -301,29 +301,29 @@ class ArraysTest {
expect('b', { charArrayOf('a', 'b').max() })
}
@test fun minWith() {
@Test fun minWith() {
assertEquals(null, arrayOf<Int>().minWith(naturalOrder()) )
assertEquals("a", arrayOf("a", "B").minWith(STRING_CASE_INSENSITIVE_ORDER))
}
@test fun minWithInPrimitiveArrays() {
@Test fun minWithInPrimitiveArrays() {
expect(null, { intArrayOf().minWith(naturalOrder()) })
expect(1, { intArrayOf(1).minWith(naturalOrder()) })
expect(4, { intArrayOf(2, 3, 4).minWith(compareBy { it % 4 }) })
}
@test fun maxWith() {
@Test fun maxWith() {
assertEquals(null, arrayOf<Int>().maxWith(naturalOrder()) )
assertEquals("B", arrayOf("a", "B").maxWith(STRING_CASE_INSENSITIVE_ORDER))
}
@test fun maxWithInPrimitiveArrays() {
@Test fun maxWithInPrimitiveArrays() {
expect(null, { intArrayOf().maxWith(naturalOrder()) })
expect(1, { intArrayOf(1).maxWith(naturalOrder()) })
expect(-4, { intArrayOf(2, 3, -4).maxWith(compareBy { it*it }) })
}
@test fun minBy() {
@Test fun minBy() {
expect(null, { arrayOf<Int>().minBy { it } })
expect(1, { arrayOf(1).minBy { it } })
expect(3, { arrayOf(2, 3).minBy { -it } })
@@ -331,7 +331,7 @@ class ArraysTest {
expect("b", { arrayOf("b", "abc").minBy { it.length } })
}
@test fun minByInPrimitiveArrays() {
@Test fun minByInPrimitiveArrays() {
expect(null, { intArrayOf().minBy { it } })
expect(1, { intArrayOf(1).minBy { it } })
expect(3, { intArrayOf(2, 3).minBy { -it } })
@@ -342,7 +342,7 @@ class ArraysTest {
expect(2.0, { doubleArrayOf(2.0, 3.0).minBy { Math.sqrt(it) } })
}
@test fun maxBy() {
@Test fun maxBy() {
expect(null, { arrayOf<Int>().maxBy { it } })
expect(1, { arrayOf(1).maxBy { it } })
expect(2, { arrayOf(2, 3).maxBy { -it } })
@@ -350,7 +350,7 @@ class ArraysTest {
expect("abc", { arrayOf("b", "abc").maxBy { it.length } })
}
@test fun maxByInPrimitiveArrays() {
@Test fun maxByInPrimitiveArrays() {
expect(null, { intArrayOf().maxBy { it } })
expect(1, { intArrayOf(1).maxBy { it } })
expect(2, { intArrayOf(2, 3).maxBy { -it } })
@@ -361,29 +361,29 @@ class ArraysTest {
expect(3.0, { doubleArrayOf(2.0, 3.0).maxBy { Math.sqrt(it) } })
}
@test fun minIndex() {
@Test fun minIndex() {
val a = intArrayOf(1, 7, 9, -42, 54, 93)
expect(3, { a.indices.minBy { a[it] } })
}
@test fun maxIndex() {
@Test fun maxIndex() {
val a = intArrayOf(1, 7, 9, 239, 54, 93)
expect(3, { a.indices.maxBy { a[it] } })
}
@test fun minByEvaluateOnce() {
@Test fun minByEvaluateOnce() {
var c = 0
expect(1, { arrayOf(5, 4, 3, 2, 1).minBy { c++; it * it } })
assertEquals(5, c)
}
@test fun maxByEvaluateOnce() {
@Test fun maxByEvaluateOnce() {
var c = 0
expect(5, { arrayOf(5, 4, 3, 2, 1).maxBy { c++; it * it } })
assertEquals(5, c)
}
@test fun sum() {
@Test fun sum() {
expect(0) { arrayOf<Int>().sum() }
expect(14) { arrayOf(2, 3, 9).sum() }
expect(3.0) { arrayOf(1.0, 2.0).sum() }
@@ -393,7 +393,7 @@ class ArraysTest {
expect(3.0F) { arrayOf<Float>(1.0F, 2.0F).sum() }
}
@test fun sumInPrimitiveArrays() {
@Test fun sumInPrimitiveArrays() {
expect(0) { intArrayOf().sum() }
expect(14) { intArrayOf(2, 3, 9).sum() }
expect(3.0) { doubleArrayOf(1.0, 2.0).sum() }
@@ -403,7 +403,7 @@ class ArraysTest {
expect(3.0F) { floatArrayOf(1.0F, 2.0F).sum() }
}
@test fun average() {
@Test fun average() {
expect(0.0) { arrayOf<Int>().average() }
expect(3.8) { arrayOf(1, 2, 5, 8, 3).average() }
expect(2.1) { arrayOf(1.6, 2.6, 3.6, 0.6).average() }
@@ -414,7 +414,7 @@ class ArraysTest {
// for each arr with size > 0 arr.average() = arr.sum().toDouble() / arr.size()
}
@test fun indexOfInPrimitiveArrays() {
@Test fun indexOfInPrimitiveArrays() {
expect(-1) { byteArrayOf(1, 2, 3).indexOf(0) }
expect(0) { byteArrayOf(1, 2, 3).indexOf(1) }
expect(1) { byteArrayOf(1, 2, 3).indexOf(2) }
@@ -455,7 +455,7 @@ class ArraysTest {
expect(-1) { booleanArrayOf(true).indexOf(false) }
}
@test fun indexOf() {
@Test fun indexOf() {
expect(-1) { arrayOf("cat", "dog", "bird").indexOf("mouse") }
expect(0) { arrayOf("cat", "dog", "bird").indexOf("cat") }
expect(1) { arrayOf("cat", "dog", "bird").indexOf("dog") }
@@ -473,7 +473,7 @@ class ArraysTest {
expect(2) { sequenceOf("cat", "dog", "bird").indexOfFirst { it.endsWith('d') } }
}
@test fun lastIndexOf() {
@Test fun lastIndexOf() {
expect(-1) { arrayOf("cat", "dog", "bird").lastIndexOf("mouse") }
expect(0) { arrayOf("cat", "dog", "bird").lastIndexOf("cat") }
expect(1) { arrayOf("cat", "dog", "bird").lastIndexOf("dog") }
@@ -493,7 +493,7 @@ class ArraysTest {
expect(3) { sequenceOf("cat", "dog", "bird", "red").indexOfLast { it.endsWith('d') } }
}
@test fun isEmpty() {
@Test fun isEmpty() {
assertTrue(emptyArray<String>().isEmpty())
assertFalse(arrayOf("").isEmpty())
assertTrue(intArrayOf().isEmpty())
@@ -514,12 +514,12 @@ class ArraysTest {
assertFalse(booleanArrayOf(false).isEmpty())
}
@test fun isNotEmpty() {
@Test fun isNotEmpty() {
assertFalse(intArrayOf().isNotEmpty())
assertTrue(intArrayOf(1).isNotEmpty())
}
@test fun plusInference() {
@Test fun plusInference() {
val arrayOfArrays: Array<Array<out Any>> = arrayOf(arrayOf<Any>("s") as Array<out Any>)
val elementArray = arrayOf<Any>("a") as Array<out Any>
val arrayPlusElement: Array<Array<out Any>> = arrayOfArrays.plusElement(elementArray)
@@ -533,7 +533,7 @@ class ArraysTest {
}
@test fun plus() {
@Test fun plus() {
assertEquals(listOf("1", "2", "3", "4"), listOf("1", "2") + arrayOf("3", "4"))
assertArrayNotSameButEquals(arrayOf("1", "2", "3"), arrayOf("1", "2") + "3")
assertArrayNotSameButEquals(arrayOf("1", "2", "3", "4"), arrayOf("1", "2") + arrayOf("3", "4"))
@@ -543,7 +543,7 @@ class ArraysTest {
assertArrayNotSameButEquals(intArrayOf(1, 2, 3, 4), intArrayOf(1, 2) + intArrayOf(3, 4))
}
@test fun plusVararg() {
@Test fun plusVararg() {
fun stringOnePlus(vararg a: String) = arrayOf("1") + a
fun longOnePlus(vararg a: Long) = longArrayOf(1) + a
fun intOnePlus(vararg a: Int) = intArrayOf(1) + a
@@ -553,7 +553,7 @@ class ArraysTest {
assertArrayNotSameButEquals(longArrayOf(1, 2), longOnePlus(2), "LongArray.plus")
}
@test fun plusAssign() {
@Test fun plusAssign() {
// lets use a mutable variable
var result = arrayOf("a")
result += "foo"
@@ -562,23 +562,23 @@ class ArraysTest {
assertArrayNotSameButEquals(arrayOf("a", "foo", "beer", "cheese", "wine"), result)
}
@test fun first() {
@Test fun first() {
expect(1) { arrayOf(1, 2, 3).first() }
expect(2) { arrayOf(1, 2, 3).first { it % 2 == 0 } }
}
@test fun last() {
@Test fun last() {
expect(3) { arrayOf(1, 2, 3).last() }
expect(2) { arrayOf(1, 2, 3).last { it % 2 == 0 } }
}
@test fun contains() {
@Test fun contains() {
assertTrue(arrayOf("1", "2", "3", "4").contains("2"))
assertTrue("3" in arrayOf("1", "2", "3", "4"))
assertTrue("0" !in arrayOf("1", "2", "3", "4"))
}
@test fun slice() {
@Test fun slice() {
val iter: Iterable<Int> = listOf(3, 1, 2)
assertEquals(listOf("B"), arrayOf("A", "B", "C").slice(1..1))
@@ -595,7 +595,7 @@ class ArraysTest {
assertEquals(listOf(true, false, true), booleanArrayOf(true, false, true, true).slice(iter))
}
@test fun sliceArray() {
@Test fun sliceArray() {
val coll: Collection<Int> = listOf(3, 1, 2)
assertArrayNotSameButEquals(arrayOf("B"), arrayOf("A", "B", "C").sliceArray(1..1))
@@ -614,7 +614,7 @@ class ArraysTest {
assertArrayNotSameButEquals(booleanArrayOf(true, false, true), booleanArrayOf(true, false, true, true).sliceArray(coll))
}
@test fun asIterable() {
@Test fun asIterable() {
val arr1 = intArrayOf(1, 2, 3, 4, 5)
val iter1 = arr1.asIterable()
assertEquals(arr1.toList(), iter1.toList())
@@ -636,7 +636,7 @@ class ArraysTest {
assertEquals(iter4.toList(), emptyList<String>())
}
@test fun asList() {
@Test fun asList() {
compare(listOf(1, 2, 3), intArrayOf(1, 2, 3).asList()) { listBehavior() }
compare(listOf<Byte>(1, 2, 3), byteArrayOf(1, 2, 3).asList()) { listBehavior() }
compare(listOf(true, false), booleanArrayOf(true, false).asList()) { listBehavior() }
@@ -651,7 +651,7 @@ class ArraysTest {
assertEquals(10, intsAsList[1], "Should reflect changes in original array")
}
@test fun toPrimitiveArray() {
@Test fun toPrimitiveArray() {
val genericArray: Array<Int> = arrayOf(1, 2, 3)
val primitiveArray: IntArray = genericArray.toIntArray()
expect(3) { primitiveArray.size }
@@ -663,14 +663,14 @@ class ArraysTest {
assertEquals(charList, charArray.asList())
}
@test fun toTypedArray() {
@Test fun toTypedArray() {
val primitiveArray: LongArray = longArrayOf(1, 2, Long.MAX_VALUE)
val genericArray: Array<Long> = primitiveArray.toTypedArray()
expect(3) { genericArray.size }
assertEquals(primitiveArray.asList(), genericArray.asList())
}
@test fun copyOf() {
@Test fun copyOf() {
booleanArrayOf(true, false, true).let { assertArrayNotSameButEquals(it, it.copyOf()) }
byteArrayOf(0, 1, 2, 3, 4, 5).let { assertArrayNotSameButEquals(it, it.copyOf()) }
shortArrayOf(0, 1, 2, 3, 4, 5).let { assertArrayNotSameButEquals(it, it.copyOf()) }
@@ -681,7 +681,7 @@ class ArraysTest {
charArrayOf('0', '1', '2', '3', '4', '5').let { assertArrayNotSameButEquals(it, it.copyOf()) }
}
@test fun copyAndResize() {
@Test fun copyAndResize() {
assertArrayNotSameButEquals(arrayOf("1", "2"), arrayOf("1", "2", "3").copyOf(2))
assertArrayNotSameButEquals(arrayOf("1", "2", null), arrayOf("1", "2").copyOf(3))
@@ -695,7 +695,7 @@ class ArraysTest {
assertArrayNotSameButEquals(charArrayOf('A', 'B', '\u0000'), charArrayOf('A', 'B').copyOf(3))
}
@test fun copyOfRange() {
@Test fun copyOfRange() {
assertArrayNotSameButEquals(booleanArrayOf(true, false, true), booleanArrayOf(true, false, true, true).copyOfRange(0, 3))
assertArrayNotSameButEquals(byteArrayOf(0, 1, 2), byteArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3))
assertArrayNotSameButEquals(shortArrayOf(0, 1, 2), shortArrayOf(0, 1, 2, 3, 4, 5).copyOfRange(0, 3))
@@ -708,7 +708,7 @@ class ArraysTest {
@test fun reduceIndexed() {
@Test fun reduceIndexed() {
expect(-1) { intArrayOf(1, 2, 3).reduceIndexed { index, a, b -> index + a - b } }
expect(-1.toLong()) { longArrayOf(1, 2, 3).reduceIndexed { index, a, b -> index + a - b } }
expect(-1F) { floatArrayOf(1F, 2F, 3F).reduceIndexed { index, a, b -> index + a - b } }
@@ -724,7 +724,7 @@ class ArraysTest {
}
}
@test fun reduceRightIndexed() {
@Test fun reduceRightIndexed() {
expect(1) { intArrayOf(1, 2, 3).reduceRightIndexed { index, a, b -> index + a - b } }
expect(1.toLong()) { longArrayOf(1, 2, 3).reduceRightIndexed { index, a, b -> index + a - b } }
expect(1F) { floatArrayOf(1F, 2F, 3F).reduceRightIndexed { index, a, b -> index + a - b } }
@@ -740,7 +740,7 @@ class ArraysTest {
}
}
@test fun reduce() {
@Test fun reduce() {
expect(-4) { intArrayOf(1, 2, 3).reduce { a, b -> a - b } }
expect(-4.toLong()) { longArrayOf(1, 2, 3).reduce { a, b -> a - b } }
expect(-4F) { floatArrayOf(1F, 2F, 3F).reduce { a, b -> a - b } }
@@ -756,7 +756,7 @@ class ArraysTest {
}
}
@test fun reduceRight() {
@Test fun reduceRight() {
expect(2) { intArrayOf(1, 2, 3).reduceRight { a, b -> a - b } }
expect(2.toLong()) { longArrayOf(1, 2, 3).reduceRight { a, b -> a - b } }
expect(2F) { floatArrayOf(1F, 2F, 3F).reduceRight { a, b -> a - b } }
@@ -772,7 +772,7 @@ class ArraysTest {
}
}
@test fun reverseInPlace() {
@Test fun reverseInPlace() {
fun <TArray, T> doTest(build: Iterable<Int>.() -> TArray, reverse: TArray.() -> Unit, snapshot: TArray.() -> List<T>) {
val arrays = (0..4).map { n -> (1..n).build() }
@@ -797,7 +797,7 @@ class ArraysTest {
}
@test fun reversed() {
@Test fun reversed() {
expect(listOf(3, 2, 1)) { intArrayOf(1, 2, 3).reversed() }
expect(listOf<Byte>(3, 2, 1)) { byteArrayOf(1, 2, 3).reversed() }
expect(listOf<Short>(3, 2, 1)) { shortArrayOf(1, 2, 3).reversed() }
@@ -809,7 +809,7 @@ class ArraysTest {
expect(listOf("3", "2", "1")) { arrayOf("1", "2", "3").reversed() }
}
@test fun reversedArray() {
@Test fun reversedArray() {
assertArrayNotSameButEquals(intArrayOf(3, 2, 1), intArrayOf(1, 2, 3).reversedArray())
assertArrayNotSameButEquals(byteArrayOf(3, 2, 1), byteArrayOf(1, 2, 3).reversedArray())
assertArrayNotSameButEquals(shortArrayOf(3, 2, 1), shortArrayOf(1, 2, 3).reversedArray())
@@ -822,7 +822,7 @@ class ArraysTest {
assertArrayNotSameButEquals(arrayOf("3", "2", "1"), (arrayOf("1", "2", "3") as Array<out String>).reversedArray())
}
@test fun drop() {
@Test fun drop() {
expect(listOf(1), { intArrayOf(1).drop(0) })
expect(listOf(), { intArrayOf().drop(1) })
expect(listOf(), { intArrayOf(1).drop(1) })
@@ -840,7 +840,7 @@ class ArraysTest {
}
}
@test fun dropLast() {
@Test fun dropLast() {
expect(listOf(), { intArrayOf().dropLast(1) })
expect(listOf(), { intArrayOf(1).dropLast(1) })
expect(listOf(1), { intArrayOf(1).dropLast(0) })
@@ -858,7 +858,7 @@ class ArraysTest {
}
}
@test fun dropWhile() {
@Test fun dropWhile() {
expect(listOf(), { intArrayOf().dropWhile { it < 3 } })
expect(listOf(), { intArrayOf(1).dropWhile { it < 3 } })
expect(listOf(3, 1), { intArrayOf(2, 3, 1).dropWhile { it < 3 } })
@@ -872,7 +872,7 @@ class ArraysTest {
expect(listOf("b", "a"), { arrayOf("a", "b", "a").dropWhile { it < "b" } })
}
@test fun dropLastWhile() {
@Test fun dropLastWhile() {
expect(listOf(), { intArrayOf().dropLastWhile { it < 3 } })
expect(listOf(), { intArrayOf(1).dropLastWhile { it < 3 } })
expect(listOf(2, 3), { intArrayOf(2, 3, 1).dropLastWhile { it < 3 } })
@@ -886,7 +886,7 @@ class ArraysTest {
expect(listOf("a", "b"), { arrayOf("a", "b", "a").dropLastWhile { it < "b" } })
}
@test fun take() {
@Test fun take() {
expect(listOf(), { intArrayOf().take(1) })
expect(listOf(), { intArrayOf(1).take(0) })
expect(listOf(1), { intArrayOf(1).take(1) })
@@ -904,7 +904,7 @@ class ArraysTest {
}
}
@test fun takeLast() {
@Test fun takeLast() {
expect(listOf(), { intArrayOf().takeLast(1) })
expect(listOf(), { intArrayOf(1).takeLast(0) })
expect(listOf(1), { intArrayOf(1).takeLast(1) })
@@ -922,7 +922,7 @@ class ArraysTest {
}
}
@test fun takeWhile() {
@Test fun takeWhile() {
expect(listOf(), { intArrayOf().takeWhile { it < 3 } })
expect(listOf(1), { intArrayOf(1).takeWhile { it < 3 } })
expect(listOf(2), { intArrayOf(2, 3, 1).takeWhile { it < 3 } })
@@ -936,7 +936,7 @@ class ArraysTest {
expect(listOf("a"), { arrayOf("a", "c", "b").takeWhile { it < "c" } })
}
@test fun takeLastWhile() {
@Test fun takeLastWhile() {
expect(listOf(), { intArrayOf().takeLastWhile { it < 3 } })
expect(listOf(1), { intArrayOf(1).takeLastWhile { it < 3 } })
expect(listOf(1), { intArrayOf(2, 3, 1).takeLastWhile { it < 3 } })
@@ -950,7 +950,7 @@ class ArraysTest {
expect(listOf("b"), { arrayOf("a", "c", "b").takeLastWhile { it < "c" } })
}
@test fun filter() {
@Test fun filter() {
expect(listOf(), { intArrayOf().filter { it > 2 } })
expect(listOf(), { intArrayOf(1).filter { it > 2 } })
expect(listOf(3), { intArrayOf(2, 3).filter { it > 2 } })
@@ -964,7 +964,7 @@ class ArraysTest {
expect(listOf("b"), { arrayOf("a", "b").filter { it > "a" } })
}
@test fun filterIndexed() {
@Test fun filterIndexed() {
expect(listOf(), { intArrayOf().filterIndexed { i, v -> i > v } })
expect(listOf(2, 5, 8), { intArrayOf(2, 4, 3, 5, 8).filterIndexed { index, value -> index % 2 == value % 2 } })
expect(listOf<Long>(2, 5, 8), { longArrayOf(2, 4, 3, 5, 8).filterIndexed { index, value -> index % 2 == (value % 2).toInt() } })
@@ -973,7 +973,7 @@ class ArraysTest {
expect(listOf("a", "c", "d"), { arrayOf("a", "b", "c", "d").filterIndexed { index, s -> s == "a" || index >= 2 } })
}
@test fun filterNot() {
@Test fun filterNot() {
expect(listOf(), { intArrayOf().filterNot { it > 2 } })
expect(listOf(1), { intArrayOf(1).filterNot { it > 2 } })
expect(listOf(2), { intArrayOf(2, 3).filterNot { it > 2 } })
@@ -987,32 +987,32 @@ class ArraysTest {
expect(listOf("a"), { arrayOf("a", "b").filterNot { it > "a" } })
}
@test fun filterNotNull() {
@Test fun filterNotNull() {
expect(listOf("a"), { arrayOf("a", null).filterNotNull() })
}
@test fun map() {
@Test fun map() {
assertEquals(listOf(1, 2, 4), arrayOf("a", "bc", "test").map { it.length })
assertEquals(listOf('a', 'b', 'c'), intArrayOf(1, 2, 3).map { 'a' + it - 1 })
assertEquals(listOf(1, 2, 3), longArrayOf(1000, 2000, 3000).map { (it / 1000).toInt() })
assertEquals(listOf(1.0, 0.5, 0.4, 0.2, 0.1), doubleArrayOf(1.0, 2.0, 2.5, 5.0, 10.0).map { 1 / it })
}
@test fun mapIndexed() {
@Test fun mapIndexed() {
assertEquals(listOf(1, 1, 2), arrayOf("a", "bc", "test").mapIndexed { index, s -> s.length - index })
assertEquals(listOf(0, 2, 2), intArrayOf(3, 2, 1).mapIndexed { index, i -> i * index })
assertEquals(listOf("0;20", "1;21", "2;22"), longArrayOf(20, 21, 22).mapIndexed { index, it -> "$index;$it" })
}
@test fun mapNotNull() {
@Test fun mapNotNull() {
assertEquals(listOf(2, 3), arrayOf("", "bc", "def").mapNotNull { if (it.isEmpty()) null else it.length })
}
@test fun mapIndexedNotNull() {
@Test fun mapIndexedNotNull() {
assertEquals(listOf(2), arrayOf("a", null, "test").mapIndexedNotNull { index, it -> it?.run { if (index != 0) length / index else null } })
}
@test fun flattenArray() {
@Test fun flattenArray() {
val arr1: Array<Array<Int>> = arrayOf(arrayOf(1, 2, 3), arrayOf(4, 5, 6))
val arr2: Array<out Array<Int>> = arr1
val arr3: Array<out Array<out Int>> = arr1
@@ -1025,7 +1025,7 @@ class ArraysTest {
assertEquals(expected, arr4.flatten())
}
@test fun asListPrimitives() {
@Test fun asListPrimitives() {
// Array of primitives
val arr = intArrayOf(1, 2, 3, 4, 2, 5)
val list = arr.asList()
@@ -1057,7 +1057,7 @@ class ArraysTest {
assertEquals(IntArray(0).asList(), emptyList<Int>())
}
@test fun asListObjects() {
@Test fun asListObjects() {
val arr = arrayOf("a", "b", "c", "d", "b", "e")
val list = arr.asList()
@@ -1090,7 +1090,7 @@ class ArraysTest {
assertEquals(Array(0, { "" }).asList(), emptyList<String>())
}
@test fun sort() {
@Test fun sort() {
val intArr = intArrayOf(5, 2, 1, 9, 80, Int.MIN_VALUE, Int.MAX_VALUE)
intArr.sort()
assertArrayNotSameButEquals(intArrayOf(Int.MIN_VALUE, 1, 2, 5, 9, 80, Int.MAX_VALUE), intArr)
@@ -1117,7 +1117,7 @@ class ArraysTest {
assertArrayNotSameButEquals(arrayOf("all", "Foo", "9", "80"), strArr)
}
@test fun sortedTests() {
@Test fun sortedTests() {
assertTrue(arrayOf<Long>().sorted().none())
assertEquals(listOf(1), arrayOf(1).sorted())
@@ -1160,7 +1160,7 @@ class ArraysTest {
}
}
@test fun sortByInPlace() {
@Test fun sortByInPlace() {
val data = arrayOf("aa" to 20, "ab" to 3, "aa" to 3)
data.sortBy { it.second }
assertArrayNotSameButEquals(arrayOf("ab" to 3, "aa" to 3, "aa" to 20), data)
@@ -1172,14 +1172,14 @@ class ArraysTest {
assertArrayNotSameButEquals(arrayOf("aa" to 20, "aa" to 3, "ab" to 3), data)
}
@test fun sortedBy() {
@Test fun sortedBy() {
val values = arrayOf("ac", "aD", "aba")
val indices = values.indices.toList().toIntArray()
assertEquals(listOf(1, 2, 0), indices.sortedBy { values[it] })
}
@test fun sortedNullableBy() {
@Test fun sortedNullableBy() {
fun String.nullIfEmpty() = if (this.isEmpty()) null else this
arrayOf(null, "").let {
expect(listOf(null, "")) { it.sortedWith(nullsFirst(compareBy { it })) }
@@ -1188,7 +1188,7 @@ class ArraysTest {
}
}
@test fun sortedWith() {
@Test fun sortedWith() {
val comparator = compareBy { it: Int -> it % 3 }.thenByDescending { it }
fun <A, T> arrayData(array: A, comparator: Comparator<T>) = ArraySortedChecker<A, T>(array, comparator)
libraries/stdlib/test/collections/CollectionJVMTest.kt
+22 -22
View File
@@ -9,7 +9,7 @@ import kotlin.test.*
import kotlin.comparisons.*
import java.util.*
import org.junit.Test as test
import org.junit.Test
class CollectionJVMTest {
@@ -21,7 +21,7 @@ class CollectionJVMTest {
private data class IdentityData(public val value: Int)
@test fun removeAllWithDifferentEquality() {
@Test fun removeAllWithDifferentEquality() {
val data = listOf(IdentityData(1), IdentityData(1))
val list = data.toMutableList()
list -= identitySetOf(data[0]) as Iterable<IdentityData>
@@ -36,7 +36,7 @@ class CollectionJVMTest {
assertTrue(set3.isEmpty(), "Array doesn't have contains, equality contains is used instead")
}
@test fun flatMap() {
@Test fun flatMap() {
val data = listOf("", "foo", "bar", "x", "")
val characters = data.flatMap { it.toList() }
println("Got list of characters ${characters}")
@@ -46,7 +46,7 @@ class CollectionJVMTest {
}
@test fun filterIntoLinkedList() {
@Test fun filterIntoLinkedList() {
val data = listOf("foo", "bar")
val foo = data.filterTo(LinkedList<String>()) { it.startsWith("f") }
@@ -61,7 +61,7 @@ class CollectionJVMTest {
}
}
@test fun filterNotIntoLinkedListOf() {
@Test fun filterNotIntoLinkedListOf() {
val data = listOf("foo", "bar")
val foo = data.filterNotTo(LinkedList<String>()) { it.startsWith("f") }
@@ -76,7 +76,7 @@ class CollectionJVMTest {
}
}
@test fun filterNotNullIntoLinkedListOf() {
@Test fun filterNotNullIntoLinkedListOf() {
val data = listOf(null, "foo", null, "bar")
val foo = data.filterNotNullTo(LinkedList<String>())
@@ -88,7 +88,7 @@ class CollectionJVMTest {
}
}
@test fun filterIntoSortedSet() {
@Test fun filterIntoSortedSet() {
val data = listOf("foo", "bar")
val sorted = data.filterTo(sortedSetOf<String>()) { it.length == 3 }
assertEquals(2, sorted.size)
@@ -98,26 +98,26 @@ class CollectionJVMTest {
}
}
@test fun first() {
@Test fun first() {
assertEquals(19, TreeSet(listOf(90, 47, 19)).first())
}
@test fun last() {
@Test fun last() {
val data = listOf("foo", "bar")
assertEquals("bar", data.last())
assertEquals(25, listOf(15, 19, 20, 25).last())
assertEquals('a', LinkedList(listOf('a')).last())
}
@test fun lastException() {
@Test fun lastException() {
assertFails { LinkedList<String>().last() }
}
@test fun contains() {
@Test fun contains() {
assertTrue(LinkedList(listOf(15, 19, 20)).contains(15))
}
@test fun toArray() {
@Test fun toArray() {
val data = listOf("foo", "bar")
val arr = data.toTypedArray()
println("Got array ${arr}")
@@ -129,7 +129,7 @@ class CollectionJVMTest {
}
}
@test fun toSortedSet() {
@Test fun toSortedSet() {
val data = listOf("foo", "Foo", "bar")
val set1 = data.toSortedSet()
assertEquals(listOf("Foo", "bar", "foo"), set1.toList())
@@ -141,11 +141,11 @@ class CollectionJVMTest {
assertEquals(listOf("bar", "foo"), set3.toList())
}
@test fun takeReturnsFirstNElements() {
@Test fun takeReturnsFirstNElements() {
expect(setOf(1, 2)) { sortedSetOf(1, 2, 3, 4, 5).take(2).toSet() }
}
@test fun filterIsInstanceList() {
@Test fun filterIsInstanceList() {
val values: List<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde")
val intValues: List<Int> = values.filterIsInstance<Int>()
@@ -164,7 +164,7 @@ class CollectionJVMTest {
assertEquals(0, charValues.size)
}
@test fun filterIsInstanceArray() {
@Test fun filterIsInstanceArray() {
val src: Array<Any> = arrayOf(1, 2, 3.toDouble(), "abc", "cde")
val intValues: List<Int> = src.filterIsInstance<Int>()
@@ -183,11 +183,11 @@ class CollectionJVMTest {
assertEquals(0, charValues.size)
}
@test fun emptyListIsSerializable() = testSingletonSerialization(emptyList<Any>())
@Test fun emptyListIsSerializable() = testSingletonSerialization(emptyList<Any>())
@test fun emptySetIsSerializable() = testSingletonSerialization(emptySet<Any>())
@Test fun emptySetIsSerializable() = testSingletonSerialization(emptySet<Any>())
@test fun emptyMapIsSerializable() = testSingletonSerialization(emptyMap<Any, Any>())
@Test fun emptyMapIsSerializable() = testSingletonSerialization(emptyMap<Any, Any>())
private fun testSingletonSerialization(value: Any) {
val result = serializeAndDeserialize(value)
@@ -209,15 +209,15 @@ class CollectionJVMTest {
return inputObjectStream.readObject() as T
}
@test fun deserializeEmptyList() = testPersistedDeserialization(
@Test fun deserializeEmptyList() = testPersistedDeserialization(
"ac ed 00 05 73 72 00 1c 6b 6f 74 6c 69 6e 2e 63 6f 6c 6c 65 63 74 69 6f 6e 73 2e 45 6d 70 74 79 4c 69 73 74 99 6f c7 d0 a7 e0 60 32 02 00 00 78 70",
emptyList<Any>())
@test fun deserializeEmptySet() = testPersistedDeserialization(
@Test fun deserializeEmptySet() = testPersistedDeserialization(
"ac ed 00 05 73 72 00 1b 6b 6f 74 6c 69 6e 2e 63 6f 6c 6c 65 63 74 69 6f 6e 73 2e 45 6d 70 74 79 53 65 74 2f 46 b0 15 76 d7 e2 f4 02 00 00 78 70",
emptySet<Any>())
@test fun deserializeEmptyMap() = testPersistedDeserialization(
@Test fun deserializeEmptyMap() = testPersistedDeserialization(
"ac ed 00 05 73 72 00 1b 6b 6f 74 6c 69 6e 2e 63 6f 6c 6c 65 63 74 69 6f 6e 73 2e 45 6d 70 74 79 4d 61 70 72 72 37 71 cb 04 4c d2 02 00 00 78 70",
emptyMap<Any, Any>())
libraries/stdlib/test/collections/CollectionTest.kt
+93 -93
View File
@@ -17,21 +17,21 @@
package test.collections
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
import test.collections.behaviors.*
import test.comparisons.STRING_CASE_INSENSITIVE_ORDER
import kotlin.comparisons.*
class CollectionTest {
@test fun joinTo() {
@Test fun joinTo() {
val data = listOf("foo", "bar")
val buffer = StringBuilder()
data.joinTo(buffer, "-", "{", "}")
assertEquals("{foo-bar}", buffer.toString())
}
@test fun joinToString() {
@Test fun joinToString() {
val data = listOf("foo", "bar")
val text = data.joinToString("-", "<", ">")
assertEquals("<foo-bar>", text)
@@ -41,7 +41,7 @@ class CollectionTest {
assertEquals("a, b, c, *", text2)
}
@test fun filterNotNull() {
@Test fun filterNotNull() {
val data = listOf(null, "foo", null, "bar")
val foo = data.filterNotNull()
@@ -54,7 +54,7 @@ class CollectionTest {
}
/*
@test fun mapNotNull() {
@Test fun mapNotNull() {
val data = listOf(null, "foo", null, "bar")
val foo = data.mapNotNull { it.length() }
assertEquals(2, foo.size())
@@ -66,7 +66,7 @@ class CollectionTest {
}
*/
@test fun listOfNotNull() {
@Test fun listOfNotNull() {
val l1: List<Int> = listOfNotNull(null)
assertTrue(l1.isEmpty())
@@ -78,7 +78,7 @@ class CollectionTest {
assertEquals(listOf("value1", "value2"), l3)
}
@test fun filterIntoSet() {
@Test fun filterIntoSet() {
val data = listOf("foo", "bar")
val foo = data.filterTo(hashSetOf<String>()) { it.startsWith("f") }
@@ -93,7 +93,7 @@ class CollectionTest {
}
}
@test fun filterIsInstanceList() {
@Test fun filterIsInstanceList() {
val values: List<Any> = listOf(1, 2, 3.0, "abc", "cde")
val numberValues: List<Number> = values.filterIsInstance<Number>()
@@ -114,7 +114,7 @@ class CollectionTest {
assertEquals(0, charValues.size)
}
@test fun filterIsInstanceArray() {
@Test fun filterIsInstanceArray() {
val src: Array<Any> = arrayOf(1, 2, 3.0, "abc", "cde")
val numberValues: List<Number> = src.filterIsInstance<Number>()
@@ -135,7 +135,7 @@ class CollectionTest {
assertEquals(0, charValues.size)
}
@test fun foldIndexed() {
@Test fun foldIndexed() {
expect(42) {
val numbers = listOf(1, 2, 3, 4)
numbers.foldIndexed(0) { index, a, b -> index * (a + b) }
@@ -152,7 +152,7 @@ class CollectionTest {
}
}
@test fun foldIndexedWithDifferentTypes() {
@Test fun foldIndexedWithDifferentTypes() {
expect(10) {
val numbers = listOf("a", "ab", "abc")
numbers.foldIndexed(1) { index, a, b -> a + b.length + index }
@@ -164,35 +164,35 @@ class CollectionTest {
}
}
@test fun foldIndexedWithNonCommutativeOperation() {
@Test fun foldIndexedWithNonCommutativeOperation() {
expect(4) {
val numbers = listOf(1, 2, 3)
numbers.foldIndexed(7) { index, a, b -> index + a - b }
}
}
@test fun foldRightIndexed() {
@Test fun foldRightIndexed() {
expect("12343210") {
val numbers = listOf(1, 2, 3, 4)
numbers.map { it.toString() }.foldRightIndexed("") { index, a, b -> a + b + index }
}
}
@test fun foldRightIndexedWithDifferentTypes() {
@Test fun foldRightIndexedWithDifferentTypes() {
expect("12343210") {
val numbers = listOf(1, 2, 3, 4)
numbers.foldRightIndexed("") { index, a, b -> "" + a + b + index }
}
}
@test fun foldRightIndexedWithNonCommutativeOperation() {
@Test fun foldRightIndexedWithNonCommutativeOperation() {
expect(-4) {
val numbers = listOf(1, 2, 3)
numbers.foldRightIndexed(7) { index, a, b -> index + a - b }
}
}
@test fun fold() {
@Test fun fold() {
// lets calculate the sum of some numbers
expect(10) {
val numbers = listOf(1, 2, 3, 4)
@@ -211,7 +211,7 @@ class CollectionTest {
}
}
@test fun foldWithDifferentTypes() {
@Test fun foldWithDifferentTypes() {
expect(7) {
val numbers = listOf("a", "ab", "abc")
numbers.fold(1) { a, b -> a + b.length }
@@ -223,49 +223,49 @@ class CollectionTest {
}
}
@test fun foldWithNonCommutativeOperation() {
@Test fun foldWithNonCommutativeOperation() {
expect(1) {
val numbers = listOf(1, 2, 3)
numbers.fold(7) { a, b -> a - b }
}
}
@test fun foldRight() {
@Test fun foldRight() {
expect("1234") {
val numbers = listOf(1, 2, 3, 4)
numbers.map { it.toString() }.foldRight("") { a, b -> a + b }
}
}
@test fun foldRightWithDifferentTypes() {
@Test fun foldRightWithDifferentTypes() {
expect("1234") {
val numbers = listOf(1, 2, 3, 4)
numbers.foldRight("") { a, b -> "" + a + b }
}
}
@test fun foldRightWithNonCommutativeOperation() {
@Test fun foldRightWithNonCommutativeOperation() {
expect(-5) {
val numbers = listOf(1, 2, 3)
numbers.foldRight(7) { a, b -> a - b }
}
}
@test
@Test
fun zipTransform() {
expect(listOf("ab", "bc", "cd")) {
listOf("a", "b", "c").zip(listOf("b", "c", "d")) { a, b -> a + b }
}
}
@test
@Test
fun zip() {
expect(listOf("a" to "b", "b" to "c", "c" to "d")) {
listOf("a", "b", "c").zip(listOf("b", "c", "d"))
}
}
@test fun partition() {
@Test fun partition() {
val data = listOf("foo", "bar", "something", "xyz")
val pair = data.partition { it.length == 3 }
@@ -273,7 +273,7 @@ class CollectionTest {
assertEquals(listOf("something"), pair.second, "pair.second")
}
@test fun reduceIndexed() {
@Test fun reduceIndexed() {
expect("123") {
val list = listOf("1", "2", "3", "4")
list.reduceIndexed { index, a, b -> if (index == 3) a else a + b }
@@ -293,7 +293,7 @@ class CollectionTest {
}
}
@test fun reduceRightIndexed() {
@Test fun reduceRightIndexed() {
expect("234") {
val list = listOf("1", "2", "3", "4")
list.reduceRightIndexed { index, a, b -> if (index == 0) b else a + b }
@@ -313,7 +313,7 @@ class CollectionTest {
}
}
@test fun reduce() {
@Test fun reduce() {
expect("1234") {
val list = listOf("1", "2", "3", "4")
list.reduce { a, b -> a + b }
@@ -324,7 +324,7 @@ class CollectionTest {
}
}
@test fun reduceRight() {
@Test fun reduceRight() {
expect("1234") {
val list = listOf("1", "2", "3", "4")
list.reduceRight { a, b -> a + b }
@@ -335,7 +335,7 @@ class CollectionTest {
}
}
@test fun groupBy() {
@Test fun groupBy() {
val words = listOf("a", "abc", "ab", "def", "abcd")
val byLength = words.groupBy { it.length }
assertEquals(4, byLength.size)
@@ -352,7 +352,7 @@ class CollectionTest {
assertEquals(listOf("abc", "def"), l3)
}
@test fun groupByKeysAndValues() {
@Test fun groupByKeysAndValues() {
val nameToTeam = listOf("Alice" to "Marketing", "Bob" to "Sales", "Carol" to "Marketing")
val namesByTeam = nameToTeam.groupBy({ it.second }, { it.first })
assertEquals(
@@ -367,14 +367,14 @@ class CollectionTest {
assertEquals(namesByTeam, mutableNamesByTeam)
}
@test fun plusRanges() {
@Test fun plusRanges() {
val range1 = 1..3
val range2 = 4..7
val combined = range1 + range2
assertEquals((1..7).toList(), combined)
}
@test fun mapRanges() {
@Test fun mapRanges() {
val range = (1..3).map { it * 2 }
assertEquals(listOf(2, 4, 6), range)
}
@@ -386,17 +386,17 @@ class CollectionTest {
assertEquals(listOf("foo", "bar", "cheese", "wine"), list2)
}
@test fun plusElement() = testPlus { it + "cheese" + "wine" }
@test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
@test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
@test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
@Test fun plusElement() = testPlus { it + "cheese" + "wine" }
@Test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
@Test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
@Test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
@test fun plusCollectionBug() {
@Test fun plusCollectionBug() {
val list = listOf("foo", "bar") + listOf("cheese", "wine")
assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
}
@test fun plusCollectionInference() {
@Test fun plusCollectionInference() {
val listOfLists = listOf(listOf("s"))
val elementList = listOf("a")
val result: List<List<String>> = listOfLists.plusElement(elementList)
@@ -409,7 +409,7 @@ class CollectionTest {
assertEquals(listOf("a", listOf("b")), listOfAnyAndList, "should be list + Any")
}
@test fun plusAssign() {
@Test fun plusAssign() {
// lets use a mutable variable of readonly list
var l: List<String> = listOf("cheese")
val lOriginal = l
@@ -436,12 +436,12 @@ class CollectionTest {
assertEquals(expected_, b.toList())
}
@test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
@test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
@test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
@test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
@Test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
@Test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
@Test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
@Test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
@test fun minusIsEager() {
@Test fun minusIsEager() {
val source = listOf("foo", "bar")
val list = arrayListOf<String>()
val result = source - list
@@ -452,7 +452,7 @@ class CollectionTest {
assertEquals(source, result)
}
@test fun minusAssign() {
@Test fun minusAssign() {
// lets use a mutable variable of readonly list
val data: List<String> = listOf("cheese", "foo", "beer", "cheese", "wine")
var l = data
@@ -475,7 +475,7 @@ class CollectionTest {
@test fun requireNoNulls() {
@Test fun requireNoNulls() {
val data = arrayListOf<String?>("foo", "bar")
val notNull = data.requireNoNulls()
assertEquals(listOf("foo", "bar"), notNull)
@@ -488,7 +488,7 @@ class CollectionTest {
}
}
@test fun reverseInPlace() {
@Test fun reverseInPlace() {
val data = arrayListOf<String>()
data.reverse()
assertTrue(data.isEmpty())
@@ -506,7 +506,7 @@ class CollectionTest {
assertEquals(listOf("zoo", "foo", "bar"), data)
}
@test fun reversed() {
@Test fun reversed() {
val data = listOf("foo", "bar")
val rev = data.reversed()
assertEquals(listOf("bar", "foo"), rev)
@@ -514,18 +514,18 @@ class CollectionTest {
}
@test fun drop() {
@Test fun drop() {
val coll = listOf("foo", "bar", "abc")
assertEquals(listOf("bar", "abc"), coll.drop(1))
assertEquals(listOf("abc"), coll.drop(2))
}
@test fun dropWhile() {
@Test fun dropWhile() {
val coll = listOf("foo", "bar", "abc")
assertEquals(listOf("bar", "abc"), coll.dropWhile { it.startsWith("f") })
}
@test fun dropLast() {
@Test fun dropLast() {
val coll = listOf("foo", "bar", "abc")
assertEquals(coll, coll.dropLast(0))
assertEquals(emptyList<String>(), coll.dropLast(coll.size))
@@ -536,7 +536,7 @@ class CollectionTest {
assertFails { coll.dropLast(-1) }
}
@test fun dropLastWhile() {
@Test fun dropLastWhile() {
val coll = listOf("Foo", "bare", "abc" )
assertEquals(coll, coll.dropLastWhile { false })
assertEquals(listOf<String>(), coll.dropLastWhile { true })
@@ -544,7 +544,7 @@ class CollectionTest {
assertEquals(listOf("Foo"), coll.dropLastWhile { it.all { it in 'a'..'z' } })
}
@test fun take() {
@Test fun take() {
val coll = listOf("foo", "bar", "abc")
assertEquals(emptyList<String>(), coll.take(0))
assertEquals(listOf("foo"), coll.take(1))
@@ -555,7 +555,7 @@ class CollectionTest {
assertFails { coll.take(-1) }
}
@test fun takeWhile() {
@Test fun takeWhile() {
val coll = listOf("foo", "bar", "abc")
assertEquals(emptyList<String>(), coll.takeWhile { false })
assertEquals(coll, coll.takeWhile { true })
@@ -563,7 +563,7 @@ class CollectionTest {
assertEquals(listOf("foo", "bar", "abc"), coll.takeWhile { it.length == 3 })
}
@test fun takeLast() {
@Test fun takeLast() {
val coll = listOf("foo", "bar", "abc")
assertEquals(emptyList<String>(), coll.takeLast(0))
@@ -575,7 +575,7 @@ class CollectionTest {
assertFails { coll.takeLast(-1) }
}
@test fun takeLastWhile() {
@Test fun takeLastWhile() {
val coll = listOf("foo", "bar", "abc")
assertEquals(emptyList<String>(), coll.takeLastWhile { false })
assertEquals(coll, coll.takeLastWhile { true })
@@ -583,21 +583,21 @@ class CollectionTest {
assertEquals(listOf("bar", "abc"), coll.takeLastWhile { it[0] < 'c' })
}
@test fun copyToArray() {
@Test fun copyToArray() {
val data = listOf("foo", "bar")
val arr = data.toTypedArray()
println("Got array ${arr}")
assertEquals(2, arr.size)
}
@test fun count() {
@Test fun count() {
val data = listOf("foo", "bar")
assertEquals(2, data.count())
assertEquals(3, hashSetOf(12, 14, 15).count())
assertEquals(0, ArrayList<Double>().count())
}
@test fun first() {
@Test fun first() {
val data = listOf("foo", "bar")
assertEquals("foo", data.first())
assertEquals(15, listOf(15, 19, 20, 25).first())
@@ -605,7 +605,7 @@ class CollectionTest {
assertFails { arrayListOf<Int>().first() }
}
@test fun last() {
@Test fun last() {
val data = listOf("foo", "bar")
assertEquals("bar", data.last())
assertEquals(25, listOf(15, 19, 20, 25).last())
@@ -613,7 +613,7 @@ class CollectionTest {
assertFails { arrayListOf<Int>().last() }
}
@test fun subscript() {
@Test fun subscript() {
val list = arrayListOf("foo", "bar")
assertEquals("foo", list[0])
assertEquals("bar", list[1])
@@ -636,7 +636,7 @@ class CollectionTest {
assertEquals(listOf("new", "thing", "works"), list)
}
@test fun indices() {
@Test fun indices() {
val data = listOf("foo", "bar")
val indices = data.indices
assertEquals(0, indices.start)
@@ -644,14 +644,14 @@ class CollectionTest {
assertEquals(0..data.size - 1, indices)
}
@test fun contains() {
@Test fun contains() {
assertFalse(hashSetOf<Int>().contains(12))
assertTrue(listOf(15, 19, 20).contains(15))
assertTrue(hashSetOf(45, 14, 13).toIterable().contains(14))
}
@test fun min() {
@Test fun min() {
expect(null, { listOf<Int>().min() })
expect(1, { listOf(1).min() })
expect(2, { listOf(2, 3).min() })
@@ -662,7 +662,7 @@ class CollectionTest {
expect(2, { listOf(2, 3).asSequence().min() })
}
@test fun max() {
@Test fun max() {
expect(null, { listOf<Int>().max() })
expect(1, { listOf(1).max() })
expect(3, { listOf(2, 3).max() })
@@ -673,21 +673,21 @@ class CollectionTest {
expect(3, { listOf(2, 3).asSequence().max() })
}
@test fun minWith() {
@Test fun minWith() {
expect(null, { listOf<Int>().minWith(naturalOrder()) })
expect(1, { listOf(1).minWith(naturalOrder()) })
expect("a", { listOf("a", "B").minWith(STRING_CASE_INSENSITIVE_ORDER) })
expect("a", { listOf("a", "B").asSequence().minWith(STRING_CASE_INSENSITIVE_ORDER) })
}
@test fun maxWith() {
@Test fun maxWith() {
expect(null, { listOf<Int>().maxWith(naturalOrder()) })
expect(1, { listOf(1).maxWith(naturalOrder()) })
expect("B", { listOf("a", "B").maxWith(STRING_CASE_INSENSITIVE_ORDER) })
expect("B", { listOf("a", "B").asSequence().maxWith(STRING_CASE_INSENSITIVE_ORDER) })
}
@test fun minBy() {
@Test fun minBy() {
expect(null, { listOf<Int>().minBy { it } })
expect(1, { listOf(1).minBy { it } })
expect(3, { listOf(2, 3).minBy { -it } })
@@ -697,7 +697,7 @@ class CollectionTest {
expect(3, { listOf(2, 3).asSequence().minBy { -it } })
}
@test fun maxBy() {
@Test fun maxBy() {
expect(null, { listOf<Int>().maxBy { it } })
expect(1, { listOf(1).maxBy { it } })
expect(2, { listOf(2, 3).maxBy { -it } })
@@ -707,7 +707,7 @@ class CollectionTest {
expect(2, { listOf(2, 3).asSequence().maxBy { -it } })
}
@test fun minByEvaluateOnce() {
@Test fun minByEvaluateOnce() {
var c = 0
expect(1, { listOf(5, 4, 3, 2, 1).minBy { c++; it * it } })
assertEquals(5, c)
@@ -716,7 +716,7 @@ class CollectionTest {
assertEquals(5, c)
}
@test fun maxByEvaluateOnce() {
@Test fun maxByEvaluateOnce() {
var c = 0
expect(5, { listOf(5, 4, 3, 2, 1).maxBy { c++; it * it } })
assertEquals(5, c)
@@ -725,7 +725,7 @@ class CollectionTest {
assertEquals(5, c)
}
@test fun sum() {
@Test fun sum() {
expect(0) { arrayListOf<Int>().sum() }
expect(14) { listOf(2, 3, 9).sum() }
expect(3.0) { listOf(1.0, 2.0).sum() }
@@ -734,7 +734,7 @@ class CollectionTest {
expect(3.0.toFloat()) { sequenceOf<Float>(1.0.toFloat(), 2.0.toFloat()).sum() }
}
@test fun average() {
@Test fun average() {
expect(0.0) { arrayListOf<Int>().average() }
expect(3.8) { listOf(1, 2, 5, 8, 3).average() }
expect(2.1) { sequenceOf(1.6, 2.6, 3.6, 0.6).average() }
@@ -744,7 +744,7 @@ class CollectionTest {
expect(n.toDouble()/2) { range.average() }
}
@test fun takeReturnsFirstNElements() {
@Test fun takeReturnsFirstNElements() {
expect(listOf(1, 2, 3, 4, 5)) { (1..10).take(5) }
expect(listOf(1, 2, 3, 4, 5)) { (1..10).toList().take(5) }
expect(listOf(1, 2)) { (1..10).take(2) }
@@ -755,7 +755,7 @@ class CollectionTest {
expect(listOf(1)) { listOf(1).take(10) }
}
@test fun sortInPlace() {
@Test fun sortInPlace() {
val data = listOf(11, 3, 7)
val asc = data.toMutableList()
@@ -767,13 +767,13 @@ class CollectionTest {
assertEquals(listOf(11, 7, 3), desc)
}
@test fun sorted() {
@Test fun sorted() {
val data = listOf(11, 3, 7)
assertEquals(listOf(3, 7, 11), data.sorted())
assertEquals(listOf(11, 7, 3), data.sortedDescending())
}
@test fun sortByInPlace() {
@Test fun sortByInPlace() {
val data = arrayListOf("aa" to 20, "ab" to 3, "aa" to 3)
data.sortBy { it.second }
assertEquals(listOf("ab" to 3, "aa" to 3, "aa" to 20), data)
@@ -785,13 +785,13 @@ class CollectionTest {
assertEquals(listOf("aa" to 20, "aa" to 3, "ab" to 3), data)
}
@test fun sortedBy() {
@Test fun sortedBy() {
assertEquals(listOf("two" to 3, "three" to 20), listOf("three" to 20, "two" to 3).sortedBy { it.second })
assertEquals(listOf("three" to 20, "two" to 3), listOf("three" to 20, "two" to 3).sortedBy { it.first })
assertEquals(listOf("three", "two"), listOf("two", "three").sortedByDescending { it.length })
}
@test fun sortedNullableBy() {
@Test fun sortedNullableBy() {
fun String.nullIfEmpty() = if (isEmpty()) null else this
listOf(null, "", "a").let {
expect(listOf(null, "", "a")) { it.sortedWith(nullsFirst(compareBy { it })) }
@@ -800,7 +800,7 @@ class CollectionTest {
}
}
@test fun sortedByNullable() {
@Test fun sortedByNullable() {
fun String.nonEmptyLength() = if (isEmpty()) null else length
listOf("", "sort", "abc").let {
assertEquals(listOf("", "abc", "sort"), it.sortedBy { it.nonEmptyLength() })
@@ -809,7 +809,7 @@ class CollectionTest {
}
}
@test fun sortedWith() {
@Test fun sortedWith() {
val comparator = compareBy<String> { it.toUpperCase().reversed() }
val data = listOf("cat", "dad", "BAD")
@@ -818,18 +818,18 @@ class CollectionTest {
expect(listOf("BAD", "dad", "cat")) { data.sortedWith(comparator.reversed().reversed()) }
}
@test fun decomposeFirst() {
@Test fun decomposeFirst() {
val (first) = listOf(1, 2)
assertEquals(first, 1)
}
@test fun decomposeSplit() {
@Test fun decomposeSplit() {
val (key, value) = "key = value".split("=").map { it.trim() }
assertEquals(key, "key")
assertEquals(value, "value")
}
@test fun decomposeList() {
@Test fun decomposeList() {
val (a, b, c, d, e) = listOf(1, 2, 3, 4, 5)
assertEquals(a, 1)
assertEquals(b, 2)
@@ -838,7 +838,7 @@ class CollectionTest {
assertEquals(e, 5)
}
@test fun decomposeArray() {
@Test fun decomposeArray() {
val (a, b, c, d, e) = arrayOf(1, 2, 3, 4, 5)
assertEquals(a, 1)
assertEquals(b, 2)
@@ -847,7 +847,7 @@ class CollectionTest {
assertEquals(e, 5)
}
@test fun decomposeIntArray() {
@Test fun decomposeIntArray() {
val (a, b, c, d, e) = intArrayOf(1, 2, 3, 4, 5)
assertEquals(a, 1)
assertEquals(b, 2)
@@ -856,44 +856,44 @@ class CollectionTest {
assertEquals(e, 5)
}
@test fun unzipList() {
@Test fun unzipList() {
val list = listOf(1 to 'a', 2 to 'b', 3 to 'c')
val (ints, chars) = list.unzip()
assertEquals(listOf(1, 2, 3), ints)
assertEquals(listOf('a', 'b', 'c'), chars)
}
@test fun unzipArray() {
@Test fun unzipArray() {
val array = arrayOf(1 to 'a', 2 to 'b', 3 to 'c')
val (ints, chars) = array.unzip()
assertEquals(listOf(1, 2, 3), ints)
assertEquals(listOf('a', 'b', 'c'), chars)
}
@test fun specialLists() {
@Test fun specialLists() {
compare(arrayListOf<Int>(), listOf<Int>()) { listBehavior() }
compare(arrayListOf<Double>(), emptyList<Double>()) { listBehavior() }
compare(arrayListOf("value"), listOf("value")) { listBehavior() }
}
@test fun specialSets() {
@Test fun specialSets() {
compare(linkedSetOf<Int>(), setOf<Int>()) { setBehavior() }
compare(hashSetOf<Double>(), emptySet<Double>()) { setBehavior() }
compare(listOf("value").toMutableSet(), setOf("value")) { setBehavior() }
}
@test fun specialMaps() {
@Test fun specialMaps() {
compare(hashMapOf<String, Int>(), mapOf<String, Int>()) { mapBehavior() }
compare(linkedMapOf<Int, String>(), emptyMap<Int, String>()) { mapBehavior() }
compare(linkedMapOf(2 to 3), mapOf(2 to 3)) { mapBehavior() }
}
@test fun toStringTest() {
@Test fun toStringTest() {
// we need toString() inside pattern because of KT-8666
assertEquals("[1, a, null, ${Long.MAX_VALUE.toString()}]", listOf(1, "a", null, Long.MAX_VALUE).toString())
}
@test fun randomAccess() {
@Test fun randomAccess() {
assertTrue(arrayListOf(1) is RandomAccess, "ArrayList is RandomAccess")
assertTrue(listOf(1, 2) is RandomAccess, "Default read-only list implementation is RandomAccess")
assertTrue(listOf(1) is RandomAccess, "Default singleton list is RandomAccess")
libraries/stdlib/test/collections/IteratorsJVMTest.kt
+2 -2
View File
@@ -1,13 +1,13 @@
@file:kotlin.jvm.JvmVersion
package test.collections
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
import java.util.*
class IteratorsJVMTest {
@test fun testEnumeration() {
@Test fun testEnumeration() {
val v = Vector<Int>()
for (i in 1..5)
v.add(i)
libraries/stdlib/test/collections/IteratorsTest.kt
+2 -2
View File
@@ -1,10 +1,10 @@
package test.collections
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class IteratorsTest {
@test fun iterationOverIterator() {
@Test fun iterationOverIterator() {
val c = listOf(0, 1, 2, 3, 4, 5)
var s = ""
for (i in c.iterator()) {
libraries/stdlib/test/collections/MapJVMTest.kt
+7 -7
View File
@@ -6,11 +6,11 @@ import java.util.concurrent.ConcurrentMap
import kotlin.test.assertEquals
import kotlin.test.assertFails
import kotlin.test.expect
import org.junit.Test as test
import org.junit.Test
import kotlin.comparisons.*
class MapJVMTest {
@test fun createSortedMap() {
@Test fun createSortedMap() {
val map = sortedMapOf(Pair("c", 3), Pair("b", 2), Pair("a", 1))
assertEquals(1, map["a"])
assertEquals(2, map["b"])
@@ -18,7 +18,7 @@ class MapJVMTest {
assertEquals(listOf("a", "b", "c"), map.keys.toList())
}
@test fun toSortedMap() {
@Test fun toSortedMap() {
val map = mapOf(Pair("c", 3), Pair("b", 2), Pair("a", 1))
val sorted = map.toSortedMap()
assertEquals(1, sorted["a"])
@@ -27,7 +27,7 @@ class MapJVMTest {
assertEquals(listOf("a", "b", "c"), sorted.keys.toList())
}
@test fun toSortedMapWithComparator() {
@Test fun toSortedMapWithComparator() {
val map = mapOf(Pair("c", 3), Pair("bc", 2), Pair("bd", 4), Pair("abc", 1))
val sorted = map.toSortedMap(compareBy<String> { it.length }.thenBy { it })
assertEquals(listOf("c", "bc", "bd", "abc"), sorted.keys.toList())
@@ -36,7 +36,7 @@ class MapJVMTest {
assertEquals(3, sorted["c"])
}
@test fun toProperties() {
@Test fun toProperties() {
val map = mapOf("a" to "A", "b" to "B")
val prop = map.toProperties()
assertEquals(2, prop.size)
@@ -44,7 +44,7 @@ class MapJVMTest {
assertEquals("B", prop.getProperty("b", "fail"))
}
@test fun iterateAndRemove() {
@Test fun iterateAndRemove() {
val map = (1..5).associateByTo(linkedMapOf(), { it }, { 'a' + it })
val iterator = map.iterator()
while (iterator.hasNext()) {
@@ -55,7 +55,7 @@ class MapJVMTest {
assertEquals(listOf('b', 'd', 'f'), map.values.toList())
}
@test fun getOrPutFailsOnConcurrentMap() {
@Test fun getOrPutFailsOnConcurrentMap() {
val map = ConcurrentHashMap<String, Int>()
// not an error anymore
libraries/stdlib/test/collections/MapTest.kt
+45 -45
View File
@@ -1,14 +1,14 @@
package test.collections
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class MapTest {
// just a static type check
fun <T> assertStaticTypeIs(value: T) {}
@test fun getOrElse() {
@Test fun getOrElse() {
val data = mapOf<String, Int>()
val a = data.getOrElse("foo") { 2 }
assertEquals(2, a)
@@ -29,7 +29,7 @@ class MapTest {
}
@Suppress("INVISIBLE_MEMBER")
@test fun getOrImplicitDefault() {
@Test fun getOrImplicitDefault() {
val data: MutableMap<String, Int> = hashMapOf("bar" to 1)
assertFailsWith<NoSuchElementException> { data.getOrImplicitDefault("foo") }
assertEquals(1, data.getOrImplicitDefault("bar"))
@@ -50,7 +50,7 @@ class MapTest {
assertEquals(42, withReplacedDefault.getOrImplicitDefault("loop"))
}
@test fun getOrPut() {
@Test fun getOrPut() {
val data = hashMapOf<String, Int>()
val a = data.getOrPut("foo") { 2 }
assertEquals(2, a)
@@ -68,13 +68,13 @@ class MapTest {
assertEquals(1, d)
}
@test fun sizeAndEmpty() {
@Test fun sizeAndEmpty() {
val data = hashMapOf<String, Int>()
assertTrue { data.none() }
assertEquals(data.size, 0)
}
@test fun setViaIndexOperators() {
@Test fun setViaIndexOperators() {
val map = hashMapOf<String, String>()
assertTrue { map.none() }
assertEquals(map.size, 0)
@@ -86,7 +86,7 @@ class MapTest {
assertEquals("James", map["name"])
}
@test fun iterate() {
@Test fun iterate() {
val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
val list = arrayListOf<String>()
for (e in map) {
@@ -98,13 +98,13 @@ class MapTest {
assertEquals("beverage,beer,location,Mells,name,James", list.joinToString(","))
}
@test fun stream() {
@Test fun stream() {
val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
val named = map.asSequence().filter { it.key == "name" }.single()
assertEquals("James", named.value)
}
@test fun iterateWithProperties() {
@Test fun iterateWithProperties() {
val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
val list = arrayListOf<String>()
for (e in map) {
@@ -116,7 +116,7 @@ class MapTest {
assertEquals("beverage,beer,location,Mells,name,James", list.joinToString(","))
}
@test fun iterateWithExtraction() {
@Test fun iterateWithExtraction() {
val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
val list = arrayListOf<String>()
for ((key, value) in map) {
@@ -128,13 +128,13 @@ class MapTest {
assertEquals("beverage,beer,location,Mells,name,James", list.joinToString(","))
}
@test fun contains() {
@Test fun contains() {
val map = mapOf("a" to 1, "b" to 2)
assertTrue("a" in map)
assertTrue("c" !in map)
}
@test fun map() {
@Test fun map() {
val m1 = mapOf("beverage" to "beer", "location" to "Mells")
val list = m1.map { it.value + " rocks" }
@@ -142,13 +142,13 @@ class MapTest {
}
@test fun mapNotNull() {
@Test fun mapNotNull() {
val m1 = mapOf("a" to 1, "b" to null)
val list = m1.mapNotNull { it.value?.let { v -> "${it.key}$v" } }
assertEquals(listOf("a1"), list)
}
@test fun mapValues() {
@Test fun mapValues() {
val m1 = mapOf("beverage" to "beer", "location" to "Mells")
val m2 = m1.mapValues { it.value + "2" }
@@ -160,7 +160,7 @@ class MapTest {
assertEquals(mapOf("beverage" to 4, "location" to 5), m3)
}
@test fun mapKeys() {
@Test fun mapKeys() {
val m1 = mapOf("beverage" to "beer", "location" to "Mells")
val m2 = m1.mapKeys { it.key + "2" }
@@ -172,7 +172,7 @@ class MapTest {
assertEquals(mapOf(8 to "Mells"), m3)
}
@test fun createFrom() {
@Test fun createFrom() {
val pairs = arrayOf("a" to 1, "b" to 2)
val expected = mapOf(*pairs)
@@ -189,7 +189,7 @@ class MapTest {
assertNotEquals(expected, mutableMap)
}
@test fun populateTo() {
@Test fun populateTo() {
val pairs = arrayOf("a" to 1, "b" to 2)
val expected = mapOf(*pairs)
@@ -209,7 +209,7 @@ class MapTest {
assertEquals<Map<*, *>>(expected, mutableMap3)
}
@test fun createWithSelector() {
@Test fun createWithSelector() {
val map = listOf("a", "bb", "ccc").associateBy { it.length }
assertEquals(3, map.size)
assertEquals("a", map.get(1))
@@ -217,14 +217,14 @@ class MapTest {
assertEquals("ccc", map.get(3))
}
@test fun createWithSelectorAndOverwrite() {
@Test fun createWithSelectorAndOverwrite() {
val map = listOf("aa", "bb", "ccc").associateBy { it.length }
assertEquals(2, map.size)
assertEquals("bb", map.get(2))
assertEquals("ccc", map.get(3))
}
@test fun createWithSelectorForKeyAndValue() {
@Test fun createWithSelectorForKeyAndValue() {
val map = listOf("a", "bb", "ccc").associateBy({ it.length }, { it.toUpperCase() })
assertEquals(3, map.size)
assertEquals("A", map[1])
@@ -232,7 +232,7 @@ class MapTest {
assertEquals("CCC", map[3])
}
@test fun createWithPairSelector() {
@Test fun createWithPairSelector() {
val map = listOf("a", "bb", "ccc").associate { it.length to it.toUpperCase() }
assertEquals(3, map.size)
assertEquals("A", map[1])
@@ -240,20 +240,20 @@ class MapTest {
assertEquals("CCC", map[3])
}
@test fun createUsingTo() {
@Test fun createUsingTo() {
val map = mapOf("a" to 1, "b" to 2)
assertEquals(2, map.size)
assertEquals(1, map["a"])
assertEquals(2, map["b"])
}
@test fun createMutableMap() {
@Test fun createMutableMap() {
val map = mutableMapOf("b" to 1, "c" to 2)
map.put("a", 3)
assertEquals(listOf("b" to 1, "c" to 2, "a" to 3), map.toList())
}
@test fun createLinkedMap() {
@Test fun createLinkedMap() {
val map = linkedMapOf(Pair("c", 3), Pair("b", 2), Pair("a", 1))
assertEquals(1, map["a"])
assertEquals(2, map["b"])
@@ -261,7 +261,7 @@ class MapTest {
assertEquals(listOf("c", "b", "a"), map.keys.toList())
}
@test fun filter() {
@Test fun filter() {
val map = mapOf(Pair("b", 3), Pair("c", 2), Pair("a", 2))
val filteredByKey = map.filter { it.key[0] == 'b' }
assertEquals(mapOf("b" to 3), filteredByKey)
@@ -276,7 +276,7 @@ class MapTest {
assertEquals(mapOf("a" to 2, "c" to 2), filteredByValue2)
}
@test fun filterOutProjectedTo() {
@Test fun filterOutProjectedTo() {
val map: Map<out String, Int> = mapOf(Pair("b", 3), Pair("c", 2), Pair("a", 2))
val filteredByKey = map.filterTo(mutableMapOf()) { it.key[0] == 'b' }
@@ -296,7 +296,7 @@ class MapTest {
assertEquals(mapOf("a" to 2, "c" to 2), filteredByValue2)
}
@test fun any() {
@Test fun any() {
val map = mapOf(Pair("b", 3), Pair("c", 2), Pair("a", 2))
assertTrue(map.any())
assertFalse(emptyMap<String, Int>().any())
@@ -308,7 +308,7 @@ class MapTest {
assertFalse(map.any { it.value == 5 })
}
@test fun all() {
@Test fun all() {
val map = mapOf(Pair("b", 3), Pair("c", 2), Pair("a", 2))
assertTrue(map.all { it.key != "d" })
assertTrue(emptyMap<String, Int>().all { it.key == "d" })
@@ -317,7 +317,7 @@ class MapTest {
assertFalse(map.all { it.value == 2 })
}
@test fun countBy() {
@Test fun countBy() {
val map = mapOf(Pair("b", 3), Pair("c", 2), Pair("a", 2))
assertEquals(3, map.count())
@@ -328,7 +328,7 @@ class MapTest {
assertEquals(2, filteredByValue)
}
@test fun filterNot() {
@Test fun filterNot() {
val map = mapOf(Pair("b", 3), Pair("c", 2), Pair("a", 2))
val filteredByKey = map.filterNot { it.key == "b" }
assertEquals(2, filteredByKey.size)
@@ -350,18 +350,18 @@ class MapTest {
assertEquals(3, map["c"])
}
@test fun plusAssign() = testPlusAssign {
@Test fun plusAssign() = testPlusAssign {
it += "b" to 4
it += "c" to 3
}
@test fun plusAssignList() = testPlusAssign { it += listOf("c" to 3, "b" to 4) }
@Test fun plusAssignList() = testPlusAssign { it += listOf("c" to 3, "b" to 4) }
@test fun plusAssignArray() = testPlusAssign { it += arrayOf("c" to 3, "b" to 4) }
@Test fun plusAssignArray() = testPlusAssign { it += arrayOf("c" to 3, "b" to 4) }
@test fun plusAssignSequence() = testPlusAssign { it += sequenceOf("c" to 3, "b" to 4) }
@Test fun plusAssignSequence() = testPlusAssign { it += sequenceOf("c" to 3, "b" to 4) }
@test fun plusAssignMap() = testPlusAssign { it += mapOf("c" to 3, "b" to 4) }
@Test fun plusAssignMap() = testPlusAssign { it += mapOf("c" to 3, "b" to 4) }
fun testPlus(doPlus: (Map<String, Int>) -> Map<String, Int>) {
val original = mapOf("A" to 1, "B" to 2)
@@ -372,17 +372,17 @@ class MapTest {
assertEquals(3, extended["C"])
}
@test fun plus() = testPlus { it + ("C" to 3) + ("B" to 4) }
@Test fun plus() = testPlus { it + ("C" to 3) + ("B" to 4) }
@test fun plusList() = testPlus { it + listOf("C" to 3, "B" to 4) }
@Test fun plusList() = testPlus { it + listOf("C" to 3, "B" to 4) }
@test fun plusArray() = testPlus { it + arrayOf("C" to 3, "B" to 4) }
@Test fun plusArray() = testPlus { it + arrayOf("C" to 3, "B" to 4) }
@test fun plusSequence() = testPlus { it + sequenceOf("C" to 3, "B" to 4) }
@Test fun plusSequence() = testPlus { it + sequenceOf("C" to 3, "B" to 4) }
@test fun plusMap() = testPlus { it + mapOf("C" to 3, "B" to 4) }
@Test fun plusMap() = testPlus { it + mapOf("C" to 3, "B" to 4) }
@test fun plusAny() {
@Test fun plusAny() {
testPlusAny(emptyMap<String, String>(), 1 to "A")
testPlusAny(mapOf("A" to null), "A" as CharSequence to 2)
}
@@ -413,13 +413,13 @@ class MapTest {
}
@test fun plusEmptyList() = testIdempotent { it + listOf() }
@Test fun plusEmptyList() = testIdempotent { it + listOf() }
@test fun plusEmptySet() = testIdempotent { it + setOf() }
@Test fun plusEmptySet() = testIdempotent { it + setOf() }
@test fun plusAssignEmptyList() = testIdempotentAssign { it += listOf() }
@Test fun plusAssignEmptyList() = testIdempotentAssign { it += listOf() }
@test fun plusAssignEmptySet() = testIdempotentAssign { it += setOf() }
@Test fun plusAssignEmptySet() = testIdempotentAssign { it += setOf() }
}
libraries/stdlib/test/collections/MutableCollectionsTest.kt
+4 -4
View File
@@ -2,7 +2,7 @@ package test.collections
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class MutableCollectionTest {
fun <T, C: MutableCollection<T>> testOperation(before: List<T>, after: List<T>, expectedModified: Boolean, toMutableCollection: (List<T>) -> C)
@@ -16,7 +16,7 @@ class MutableCollectionTest {
= testOperation(before, after, expectedModified, { it.toMutableList() })
@test fun addAll() {
@Test fun addAll() {
val data = listOf("foo", "bar")
testOperation(emptyList(), data, true).let { assertAdd ->
@@ -34,7 +34,7 @@ class MutableCollectionTest {
}
}
@test fun removeAll() {
@Test fun removeAll() {
val content = listOf("foo", "bar", "bar")
val data = listOf("bar")
val expected = listOf("foo")
@@ -59,7 +59,7 @@ class MutableCollectionTest {
}
}
@test fun retainAll() {
@Test fun retainAll() {
val content = listOf("foo", "bar", "bar")
val expected = listOf("bar", "bar")
libraries/stdlib/test/collections/ReversedViewsTest.kt
+25 -25
View File
@@ -21,15 +21,15 @@ import test.collections.compare
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
import org.junit.Test as test
import org.junit.Test
class ReversedViewsTest {
@test fun testNullToString() {
@Test fun testNullToString() {
assertEquals("[null]", listOf<String?>(null).asReversed().toString())
}
@test fun testBehavior() {
@Test fun testBehavior() {
val original = listOf(2L, 3L, Long.MAX_VALUE)
val reversed = original.reversed()
compare(reversed, original.asReversed()) {
@@ -37,12 +37,12 @@ class ReversedViewsTest {
}
}
@test fun testSimple() {
@Test fun testSimple() {
assertEquals(listOf(3, 2, 1), listOf(1, 2, 3).asReversed())
assertEquals(listOf(3, 2, 1), listOf(1, 2, 3).asReversed().toList())
}
@test fun testRandomAccess() {
@Test fun testRandomAccess() {
val reversed = listOf(1, 2, 3).asReversed()
assertEquals(3, reversed[0])
@@ -50,21 +50,21 @@ class ReversedViewsTest {
assertEquals(1, reversed[2])
}
@test fun testDoubleReverse() {
@Test fun testDoubleReverse() {
assertEquals(listOf(1, 2, 3), listOf(1, 2, 3).asReversed().asReversed())
assertEquals(listOf(2, 3), listOf(1, 2, 3, 4).asReversed().subList(1, 3).asReversed())
}
@test fun testEmpty() {
@Test fun testEmpty() {
assertEquals(emptyList<Int>(), emptyList<Int>().asReversed())
}
@test fun testReversedSubList() {
@Test fun testReversedSubList() {
val reversed = (1..10).toList().asReversed()
assertEquals(listOf(9, 8, 7), reversed.subList(1, 4))
}
@test fun testMutableSubList() {
@Test fun testMutableSubList() {
val original = arrayListOf(1, 2, 3, 4)
val reversedSubList = original.asReversed().subList(1, 3)
@@ -78,26 +78,26 @@ class ReversedViewsTest {
assertEquals(listOf(1, 100, 4), original)
}
@test fun testMutableSimple() {
@Test fun testMutableSimple() {
assertEquals(listOf(3, 2, 1), mutableListOf(1, 2, 3).asReversed())
assertEquals(listOf(3, 2, 1), mutableListOf(1, 2, 3).asReversed().toList())
}
@test fun testMutableDoubleReverse() {
@Test fun testMutableDoubleReverse() {
assertEquals(listOf(1, 2, 3), mutableListOf(1, 2, 3).asReversed().asReversed())
assertEquals(listOf(2, 3), mutableListOf(1, 2, 3, 4).asReversed().subList(1, 3).asReversed())
}
@test fun testMutableEmpty() {
@Test fun testMutableEmpty() {
assertEquals(emptyList<Int>(), mutableListOf<Int>().asReversed())
}
@test fun testMutableReversedSubList() {
@Test fun testMutableReversedSubList() {
val reversed = (1..10).toMutableList().asReversed()
assertEquals(listOf(9, 8, 7), reversed.subList(1, 4))
}
@test fun testMutableAdd() {
@Test fun testMutableAdd() {
val original = mutableListOf(1, 2, 3)
val reversed = original.asReversed()
@@ -110,7 +110,7 @@ class ReversedViewsTest {
assertEquals(listOf(0, 1, 2, 3, 4), original)
}
@test fun testMutableSet() {
@Test fun testMutableSet() {
val original = mutableListOf(1, 2, 3)
val reversed = original.asReversed()
@@ -122,7 +122,7 @@ class ReversedViewsTest {
assertEquals(listOf(300, 200, 100), reversed)
}
@test fun testMutableRemove() {
@Test fun testMutableRemove() {
val original = mutableListOf("a", "b", "c")
val reversed = original.asReversed()
@@ -137,7 +137,7 @@ class ReversedViewsTest {
assertEquals(emptyList<String>(), original)
}
@test fun testMutableRemoveByObj() {
@Test fun testMutableRemoveByObj() {
val original = mutableListOf("a", "b", "c")
val reversed = original.asReversed()
@@ -146,7 +146,7 @@ class ReversedViewsTest {
assertEquals(listOf("b", "a"), reversed)
}
@test fun testMutableClear() {
@Test fun testMutableClear() {
val original = mutableListOf(1, 2, 3)
val reversed = original.asReversed()
@@ -156,17 +156,17 @@ class ReversedViewsTest {
assertEquals(emptyList<Int>(), original)
}
@test fun testContains() {
@Test fun testContains() {
assertTrue { 1 in listOf(1, 2, 3).asReversed() }
assertTrue { 1 in mutableListOf(1, 2, 3).asReversed() }
}
@test fun testIndexOf() {
@Test fun testIndexOf() {
assertEquals(2, listOf(1, 2, 3).asReversed().indexOf(1))
assertEquals(2, mutableListOf(1, 2, 3).asReversed().indexOf(1))
}
@test fun testBidirectionalModifications() {
@Test fun testBidirectionalModifications() {
val original = mutableListOf(1, 2, 3, 4)
val reversed = original.asReversed()
@@ -179,7 +179,7 @@ class ReversedViewsTest {
assertEquals(listOf(3, 2), reversed)
}
@test fun testGetIOOB() {
@Test fun testGetIOOB() {
val success = try {
listOf(1, 2, 3).asReversed().get(3)
true
@@ -190,7 +190,7 @@ class ReversedViewsTest {
assertFalse(success)
}
@test fun testSetIOOB() {
@Test fun testSetIOOB() {
val success = try {
mutableListOf(1, 2, 3).asReversed().set(3, 0)
true
@@ -201,7 +201,7 @@ class ReversedViewsTest {
assertFalse(success)
}
@test fun testAddIOOB() {
@Test fun testAddIOOB() {
val success = try {
mutableListOf(1, 2, 3).asReversed().add(4, 0)
true
@@ -212,7 +212,7 @@ class ReversedViewsTest {
assertFalse(success)
}
@test fun testRemoveIOOB() {
@Test fun testRemoveIOOB() {
val success = try {
mutableListOf(1, 2, 3).asReversed().removeAt(3)
true
libraries/stdlib/test/collections/SequenceJVMTest.kt
+2 -2
View File
@@ -1,12 +1,12 @@
@file:kotlin.jvm.JvmVersion
package test.collections
import org.junit.Test as test
import org.junit.Test
import kotlin.test.assertEquals
class SequenceJVMTest {
@test fun filterIsInstance() {
@Test fun filterIsInstance() {
val src: Sequence<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde").asSequence()
val intValues: Sequence<Int> = src.filterIsInstance<Int>()
libraries/stdlib/test/collections/SequenceTest.kt
+52 -53
View File
@@ -1,6 +1,5 @@
package test.collections
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
import kotlin.comparisons.*
@@ -13,20 +12,20 @@ fun fibonacci(): Sequence<Int> {
public class SequenceTest {
@test fun filterEmptySequence() {
@Test fun filterEmptySequence() {
for (sequence in listOf(emptySequence<String>(), sequenceOf<String>())) {
assertEquals(0, sequence.filter { false }.count())
assertEquals(0, sequence.filter { true }.count())
}
}
@test fun mapEmptySequence() {
@Test fun mapEmptySequence() {
for (sequence in listOf(emptySequence<String>(), sequenceOf<String>())) {
assertEquals(0, sequence.map { true }.count())
}
}
@test fun requireNoNulls() {
@Test fun requireNoNulls() {
val sequence = sequenceOf<String?>("foo", "bar")
val notNull = sequence.requireNoNulls()
assertEquals(listOf("foo", "bar"), notNull.toList())
@@ -39,37 +38,37 @@ public class SequenceTest {
}
}
@test fun filterIndexed() {
@Test fun filterIndexed() {
assertEquals(listOf(1, 2, 5, 13, 34), fibonacci().filterIndexed { index, value -> index % 2 == 1 }.take(5).toList())
}
@test fun filterNullable() {
@Test fun filterNullable() {
val data = sequenceOf(null, "foo", null, "bar")
val filtered = data.filter { it == null || it == "foo" }
assertEquals(listOf(null, "foo", null), filtered.toList())
}
@test fun filterNot() {
@Test fun filterNot() {
val data = sequenceOf(null, "foo", null, "bar")
val filtered = data.filterNot { it == null }
assertEquals(listOf("foo", "bar"), filtered.toList())
}
@test fun filterNotNull() {
@Test fun filterNotNull() {
val data = sequenceOf(null, "foo", null, "bar")
val filtered = data.filterNotNull()
assertEquals(listOf("foo", "bar"), filtered.toList())
}
@test fun mapIndexed() {
@Test fun mapIndexed() {
assertEquals(listOf(0, 1, 2, 6, 12), fibonacci().mapIndexed { index, value -> index * value }.takeWhile { i: Int -> i < 20 }.toList())
}
@test fun mapNotNull() {
@Test fun mapNotNull() {
assertEquals(listOf(0, 10, 110, 1220), fibonacci().mapNotNull { if (it % 5 == 0) it * 2 else null }.take(4).toList())
}
@test fun mapIndexedNotNull() {
@Test fun mapIndexedNotNull() {
// find which terms are divisible by their index
assertEquals(listOf("1/1", "5/5", "144/12", "46368/24", "75025/25"),
fibonacci().mapIndexedNotNull { index, value ->
@@ -78,38 +77,38 @@ public class SequenceTest {
}
@test fun mapAndJoinToString() {
@Test fun mapAndJoinToString() {
assertEquals("3, 5, 8", fibonacci().withIndex().filter { it.index > 3 }.take(3).joinToString { it.value.toString() })
}
@test fun withIndex() {
@Test fun withIndex() {
val data = sequenceOf("foo", "bar")
val indexed = data.withIndex().map { it.value.substring(0..it.index) }.toList()
assertEquals(listOf("f", "ba"), indexed)
}
@test fun filterAndTakeWhileExtractTheElementsWithinRange() {
@Test fun filterAndTakeWhileExtractTheElementsWithinRange() {
assertEquals(listOf(144, 233, 377, 610, 987), fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.toList())
}
@test fun foldReducesTheFirstNElements() {
@Test fun foldReducesTheFirstNElements() {
val sum = { a: Int, b: Int -> a + b }
assertEquals(listOf(13, 21, 34, 55, 89).fold(0, sum), fibonacci().filter { it > 10 }.take(5).fold(0, sum))
}
@test fun takeExtractsTheFirstNElements() {
@Test fun takeExtractsTheFirstNElements() {
assertEquals(listOf(0, 1, 1, 2, 3, 5, 8, 13, 21, 34), fibonacci().take(10).toList())
}
@test fun mapAndTakeWhileExtractTheTransformedElements() {
@Test fun mapAndTakeWhileExtractTheTransformedElements() {
assertEquals(listOf(0, 3, 3, 6, 9, 15), fibonacci().map { it * 3 }.takeWhile { i: Int -> i < 20 }.toList())
}
@test fun joinConcatenatesTheFirstNElementsAboveAThreshold() {
@Test fun joinConcatenatesTheFirstNElementsAboveAThreshold() {
assertEquals("13, 21, 34, 55, 89, ...", fibonacci().filter { it > 10 }.joinToString(separator = ", ", limit = 5))
}
@test fun drop() {
@Test fun drop() {
assertEquals(emptyList(), emptySequence<Int>().drop(1).toList())
listOf(2, 3, 4, 5).let { assertEquals(it, it.asSequence().drop(0).toList()) }
assertEquals("13, 21, 34, 55, 89, 144, 233, 377, 610, 987, ...", fibonacci().drop(7).joinToString(limit = 10))
@@ -117,7 +116,7 @@ public class SequenceTest {
assertFailsWith<IllegalArgumentException> { fibonacci().drop(-1) }
}
@test fun take() {
@Test fun take() {
assertEquals(emptyList(), emptySequence<Int>().take(1).toList())
assertEquals(emptyList(), fibonacci().take(0).toList())
@@ -131,7 +130,7 @@ public class SequenceTest {
assertFailsWith<IllegalArgumentException> { fibonacci().take(-1) }
}
@test fun subSequence() {
@Test fun subSequence() {
assertEquals(listOf(2, 3, 5, 8), fibonacci().drop(3).take(4).toList())
assertEquals(listOf(2, 3, 5, 8), fibonacci().take(7).drop(3).toList())
@@ -145,23 +144,23 @@ public class SequenceTest {
}
@test fun dropWhile() {
@Test fun dropWhile() {
assertEquals("233, 377, 610", fibonacci().dropWhile { it < 200 }.take(3).joinToString(limit = 10))
assertEquals("", sequenceOf(1).dropWhile { it < 200 }.joinToString(limit = 10))
}
@test fun zip() {
@Test fun zip() {
expect(listOf("ab", "bc", "cd")) {
sequenceOf("a", "b", "c").zip(sequenceOf("b", "c", "d")) { a, b -> a + b }.toList()
}
}
@test fun zipPairs() {
@Test fun zipPairs() {
val pairStr = (fibonacci() zip fibonacci().map { i -> i*2 }).joinToString(limit = 10)
assertEquals("(0, 0), (1, 2), (1, 2), (2, 4), (3, 6), (5, 10), (8, 16), (13, 26), (21, 42), (34, 68), ...", pairStr)
}
@test fun toStringJoinsNoMoreThanTheFirstTenElements() {
@Test fun toStringJoinsNoMoreThanTheFirstTenElements() {
assertEquals("0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...", fibonacci().joinToString(limit = 10))
assertEquals("13, 21, 34, 55, 89, 144, 233, 377, 610, 987, ...", fibonacci().filter { it > 10 }.joinToString(limit = 10))
assertEquals("144, 233, 377, 610, 987", fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.joinToString())
@@ -176,12 +175,12 @@ public class SequenceTest {
}
@test fun plusElement() = testPlus { it + "cheese" + "wine" }
@test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
@test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
@test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
@Test fun plusElement() = testPlus { it + "cheese" + "wine" }
@Test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
@Test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
@Test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
@test fun plusAssign() {
@Test fun plusAssign() {
// lets use a mutable variable
var seq = sequenceOf("a")
seq += "foo"
@@ -198,12 +197,12 @@ public class SequenceTest {
assertEquals(expected_, b.toList())
}
@test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
@test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
@test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
@test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
@Test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
@Test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
@Test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
@Test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
@test fun minusIsLazyIterated() {
@Test fun minusIsLazyIterated() {
val seq = sequenceOf("foo", "bar")
val list = arrayListOf<String>()
val result = seq - list
@@ -214,7 +213,7 @@ public class SequenceTest {
assertEquals(emptyList<String>(), result.toList())
}
@test fun minusAssign() {
@Test fun minusAssign() {
// lets use a mutable variable of readonly list
val data = sequenceOf("cheese", "foo", "beer", "cheese", "wine")
var l = data
@@ -229,7 +228,7 @@ public class SequenceTest {
@test fun iterationOverSequence() {
@Test fun iterationOverSequence() {
var s = ""
for (i in sequenceOf(0, 1, 2, 3, 4, 5)) {
s += i.toString()
@@ -237,7 +236,7 @@ public class SequenceTest {
assertEquals("012345", s)
}
@test fun sequenceFromFunction() {
@Test fun sequenceFromFunction() {
var count = 3
val sequence = generateSequence {
@@ -253,7 +252,7 @@ public class SequenceTest {
}
}
@test fun sequenceFromFunctionWithInitialValue() {
@Test fun sequenceFromFunctionWithInitialValue() {
val values = generateSequence(3) { n -> if (n > 0) n - 1 else null }
val expected = listOf(3, 2, 1, 0)
assertEquals(expected, values.toList())
@@ -279,7 +278,7 @@ public class SequenceTest {
}
@test fun sequenceFromIterator() {
@Test fun sequenceFromIterator() {
val list = listOf(3, 2, 1, 0)
val iterator = list.iterator()
val sequence = iterator.asSequence()
@@ -289,7 +288,7 @@ public class SequenceTest {
}
}
@test fun makeSequenceOneTimeConstrained() {
@Test fun makeSequenceOneTimeConstrained() {
val sequence = sequenceOf(1, 2, 3, 4)
sequence.toList()
sequence.toList()
@@ -309,13 +308,13 @@ public class SequenceTest {
return result
}
@test fun sequenceExtensions() {
@Test fun sequenceExtensions() {
val d = ArrayList<Int>()
sequenceOf(0, 1, 2, 3, 4, 5).takeWhileTo(d, { i -> i < 4 })
assertEquals(4, d.size)
}
@test fun flatMapAndTakeExtractTheTransformedElements() {
@Test fun flatMapAndTakeExtractTheTransformedElements() {
val expected = listOf(
'3', // fibonacci(4) = 3
'5', // fibonacci(5) = 5
@@ -329,22 +328,22 @@ public class SequenceTest {
assertEquals(expected, fibonacci().drop(4).flatMap { it.toString().asSequence() }.take(10).toList())
}
@test fun flatMap() {
@Test fun flatMap() {
val result = sequenceOf(1, 2).flatMap { (0..it).asSequence() }
assertEquals(listOf(0, 1, 0, 1, 2), result.toList())
}
@test fun flatMapOnEmpty() {
@Test fun flatMapOnEmpty() {
val result = sequenceOf<Int>().flatMap { (0..it).asSequence() }
assertTrue(result.none())
}
@test fun flatMapWithEmptyItems() {
@Test fun flatMapWithEmptyItems() {
val result = sequenceOf(1, 2, 4).flatMap { if (it == 2) sequenceOf<Int>() else (it - 1..it).asSequence() }
assertEquals(listOf(0, 1, 3, 4), result.toList())
}
@test fun flatten() {
@Test fun flatten() {
val expected = listOf(0, 1, 0, 1, 2)
val seq = sequenceOf((0..1).asSequence(), (0..2).asSequence()).flatten()
@@ -360,31 +359,31 @@ public class SequenceTest {
assertEquals(expected, seqMappedIterable.toList())
}
@test fun distinct() {
@Test fun distinct() {
val sequence = fibonacci().dropWhile { it < 10 }.take(20)
assertEquals(listOf(1, 2, 3, 0), sequence.map { it % 4 }.distinct().toList())
}
@test fun distinctBy() {
@Test fun distinctBy() {
val sequence = fibonacci().dropWhile { it < 10 }.take(20)
assertEquals(listOf(13, 34, 55, 144), sequence.distinctBy { it % 4 }.toList())
}
@test fun unzip() {
@Test fun unzip() {
val seq = sequenceOf(1 to 'a', 2 to 'b', 3 to 'c')
val (ints, chars) = seq.unzip()
assertEquals(listOf(1, 2, 3), ints)
assertEquals(listOf('a', 'b', 'c'), chars)
}
@test fun sorted() {
@Test fun sorted() {
sequenceOf(3, 7, 5).let {
it.sorted().iterator().assertSorted { a, b -> a <= b }
it.sortedDescending().iterator().assertSorted { a, b -> a >= b }
}
}
@test fun sortedBy() {
@Test fun sortedBy() {
sequenceOf("it", "greater", "less").let {
it.sortedBy { it.length }.iterator().assertSorted { a, b -> compareValuesBy(a, b) { it.length } <= 0 }
it.sortedByDescending { it.length }.iterator().assertSorted { a, b -> compareValuesBy(a, b) { it.length } >= 0 }
@@ -396,7 +395,7 @@ public class SequenceTest {
}
}
@test fun sortedWith() {
@Test fun sortedWith() {
val comparator = compareBy { s: String -> s.reversed() }
assertEquals(listOf("act", "wast", "test"), sequenceOf("act", "test", "wast").sortedWith(comparator).toList())
}
libraries/stdlib/test/collections/SetOperationsTest.kt
+15 -15
View File
@@ -1,32 +1,32 @@
package test.collections
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class SetOperationsTest {
@test fun distinct() {
@Test fun distinct() {
assertEquals(listOf(1, 3, 5), listOf(1, 3, 3, 1, 5, 1, 3).distinct())
assertTrue(listOf<Int>().distinct().isEmpty())
}
@test fun distinctBy() {
@Test fun distinctBy() {
assertEquals(listOf("some", "cat", "do"), arrayOf("some", "case", "cat", "do", "dog", "it").distinctBy { it.length })
assertTrue(charArrayOf().distinctBy { it }.isEmpty())
}
@test fun union() {
@Test fun union() {
assertEquals(listOf(1, 3, 5), listOf(1, 3).union(listOf(5)).toList())
assertEquals(listOf(1), listOf<Int>().union(listOf(1)).toList())
}
@test fun subtract() {
@Test fun subtract() {
assertEquals(listOf(1, 3), listOf(1, 3).subtract(listOf(5)).toList())
assertEquals(listOf(1, 3), listOf(1, 3, 5).subtract(listOf(5)).toList())
assertTrue(listOf(1, 3, 5).subtract(listOf(1, 3, 5)).none())
assertTrue(listOf<Int>().subtract(listOf(1)).none())
}
@test fun intersect() {
@Test fun intersect() {
assertTrue(listOf(1, 3).intersect(listOf(5)).none())
assertEquals(listOf(5), listOf(1, 3, 5).intersect(listOf(5)).toList())
assertEquals(listOf(1, 3, 5), listOf(1, 3, 5).intersect(listOf(1, 3, 5)).toList())
@@ -40,12 +40,12 @@ class SetOperationsTest {
assertEquals(setOf("foo", "bar", "cheese", "wine"), set2)
}
@test fun plusElement() = testPlus { it + "bar" + "cheese" + "wine" }
@test fun plusCollection() = testPlus { it + listOf("bar", "cheese", "wine") }
@test fun plusArray() = testPlus { it + arrayOf("bar", "cheese", "wine") }
@test fun plusSequence() = testPlus { it + sequenceOf("bar", "cheese", "wine") }
@Test fun plusElement() = testPlus { it + "bar" + "cheese" + "wine" }
@Test fun plusCollection() = testPlus { it + listOf("bar", "cheese", "wine") }
@Test fun plusArray() = testPlus { it + arrayOf("bar", "cheese", "wine") }
@Test fun plusSequence() = testPlus { it + sequenceOf("bar", "cheese", "wine") }
@test fun plusAssign() {
@Test fun plusAssign() {
// lets use a mutable variable
var set = setOf("a")
val setOriginal = set
@@ -70,9 +70,9 @@ class SetOperationsTest {
assertEquals(setOf("foo"), b)
}
@test fun minusElement() = testMinus { it - "bar" - "zoo" }
@test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
@test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
@test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
@Test fun minusElement() = testMinus { it - "bar" - "zoo" }
@Test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
@Test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
@Test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
}
libraries/stdlib/test/concurrent/ThreadTest.kt
+4 -4
View File
@@ -4,13 +4,13 @@ package test.concurrent
import kotlin.concurrent.*
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
import java.util.concurrent.*
import java.util.concurrent.TimeUnit.*
class ThreadTest {
@test fun scheduledTask() {
@Test fun scheduledTask() {
val pool = Executors.newFixedThreadPool(1)
val countDown = CountDownLatch(1)
@@ -20,7 +20,7 @@ class ThreadTest {
assertTrue(countDown.await(2, SECONDS), "Count down is executed")
}
@test fun callableInvoke() {
@Test fun callableInvoke() {
val pool = Executors.newFixedThreadPool(1)
val future = pool.submit<String> { // type specification required here to choose overload for callable, see KT-7882
@@ -29,7 +29,7 @@ class ThreadTest {
assertEquals("Hello", future.get(2, SECONDS))
}
@test fun threadLocalGetOrSet() {
@Test fun threadLocalGetOrSet() {
val v = ThreadLocal<String>()
assertEquals("v1", v.getOrSet { "v1" })
libraries/stdlib/test/concurrent/TimerTest.kt
+2 -2
View File
@@ -7,10 +7,10 @@ import kotlin.test.*
import java.util.concurrent.atomic.AtomicInteger
import java.util.Timer
import org.junit.Test as test
import org.junit.Test
class TimerTest {
@test fun scheduledTask() {
@Test fun scheduledTask() {
val counter = AtomicInteger(0)
val timer = Timer()
libraries/stdlib/test/io/Files.kt
+27 -27
View File
@@ -3,7 +3,7 @@ package test.io
import java.io.*
import java.util.*
import org.junit.Test as test
import org.junit.Test
import kotlin.io.walkTopDown
import kotlin.test.*
@@ -13,13 +13,13 @@ class FilesTest {
private val isBackslashSeparator = File.separatorChar == '\\'
@test fun testPath() {
@Test fun testPath() {
val fileSuf = System.currentTimeMillis().toString()
val file1 = createTempFile("temp", fileSuf)
assertTrue(file1.path.endsWith(fileSuf), file1.path)
}
@test fun testCreateTempDir() {
@Test fun testCreateTempDir() {
val dirSuf = System.currentTimeMillis().toString()
val dir1 = createTempDir("temp", dirSuf)
assertTrue(dir1.exists() && dir1.isDirectory && dir1.name.startsWith("temp") && dir1.name.endsWith(dirSuf))
@@ -38,7 +38,7 @@ class FilesTest {
dir3.delete()
}
@test fun testCreateTempFile() {
@Test fun testCreateTempFile() {
val fileSuf = System.currentTimeMillis().toString()
val file1 = createTempFile("temp", fileSuf)
assertTrue(file1.exists() && file1.name.startsWith("temp") && file1.name.endsWith(fileSuf))
@@ -57,7 +57,7 @@ class FilesTest {
file3.delete()
}
@test fun listFilesWithFilter() {
@Test fun listFilesWithFilter() {
val dir = createTempDir("temp")
createTempFile("temp1", ".kt", dir)
@@ -72,7 +72,7 @@ class FilesTest {
assertEquals(2, result2!!.size)
}
@test fun relativeToRooted() {
@Test fun relativeToRooted() {
val file1 = File("/foo/bar/baz")
val file2 = File("/foo/baa/ghoo")
@@ -116,7 +116,7 @@ class FilesTest {
}
}
@test fun relativeToRelative() {
@Test fun relativeToRelative() {
val nested = File("foo/bar")
val base = File("foo")
@@ -150,7 +150,7 @@ class FilesTest {
}
}
@test fun relativeToFails() {
@Test fun relativeToFails() {
val absolute = File("/foo/bar/baz")
val relative = File("foo/bar")
val networkShare1 = File("""\\my.host\share1/folder""")
@@ -177,7 +177,7 @@ class FilesTest {
}
}
@test fun relativeTo() {
@Test fun relativeTo() {
assertEquals("kotlin", File("src/kotlin").toRelativeString(File("src")))
assertEquals("", File("dir").toRelativeString(File("dir")))
assertEquals("..", File("dir").toRelativeString(File("dir/subdir")))
@@ -192,7 +192,7 @@ class FilesTest {
assertEquals(elements, components.segments.map { it.toString() })
}
@test fun filePathComponents() {
@Test fun filePathComponents() {
checkFilePathComponents(File("/foo/bar"), File("/"), listOf("foo", "bar"))
checkFilePathComponents(File("/foo/bar/gav"), File("/"), listOf("foo", "bar", "gav"))
checkFilePathComponents(File("/foo/bar/gav/"), File("/"), listOf("foo", "bar", "gav"))
@@ -213,7 +213,7 @@ class FilesTest {
checkFilePathComponents(File(".."), File(""), listOf(".."))
}
@test fun fileRoot() {
@Test fun fileRoot() {
val rooted = File("/foo/bar")
assertTrue(rooted.isRooted)
// assertEquals("/", rooted.root.invariantSeparatorsPath)
@@ -233,7 +233,7 @@ class FilesTest {
// assertEquals("", relative.rootName)
}
@test fun startsWith() {
@Test fun startsWith() {
assertTrue(File("foo/bar").startsWith(File("foo/bar")))
assertTrue(File("foo/bar").startsWith(File("foo")))
assertTrue(File("foo/bar").startsWith(""))
@@ -258,7 +258,7 @@ class FilesTest {
}
}
@test fun endsWith() {
@Test fun endsWith() {
assertTrue(File("/foo/bar").endsWith("bar"))
assertTrue(File("/foo/bar").endsWith("foo/bar"))
assertTrue(File("/foo/bar").endsWith("/foo/bar"))
@@ -277,7 +277,7 @@ class FilesTest {
}
/*
@test fun subPath() {
@Test fun subPath() {
if (isBackslashSeparator) {
// Check only in Windows
assertEquals(File("mike"), File("//my.host.net/home/mike/temp").subPath(0, 1))
@@ -289,7 +289,7 @@ class FilesTest {
}
*/
@test fun normalize() {
@Test fun normalize() {
assertEquals(File("/foo/bar/baaz"), File("/foo/./bar/gav/../baaz").normalize())
assertEquals(File("/foo/bar/baaz"), File("/foo/bak/../bar/gav/../baaz").normalize())
assertEquals(File("../../bar"), File("../foo/../../bar").normalize())
@@ -302,7 +302,7 @@ class FilesTest {
assertEquals(File("/../foo"), File("/bar/../../foo").normalize())
}
@test fun resolve() {
@Test fun resolve() {
assertEquals(File("/foo/bar/gav"), File("/foo/bar").resolve("gav"))
assertEquals(File("/foo/bar/gav"), File("/foo/bar/").resolve("gav"))
assertEquals(File("/gav"), File("/foo/bar").resolve("/gav"))
@@ -322,7 +322,7 @@ class FilesTest {
// assertEquals(File("foo/bar"), File("foo").resolve("./bar"))
}
@test fun resolveSibling() {
@Test fun resolveSibling() {
assertEquals(File("/foo/gav"), File("/foo/bar").resolveSibling("gav"))
assertEquals(File("/foo/gav"), File("/foo/bar/").resolveSibling("gav"))
assertEquals(File("/gav"), File("/foo/bar").resolveSibling("/gav"))
@@ -337,7 +337,7 @@ class FilesTest {
assertEquals(File("../gav"), File("").resolveSibling("gav"))
}
@test fun extension() {
@Test fun extension() {
assertEquals("bbb", File("aaa.bbb").extension)
assertEquals("", File("aaa").extension)
assertEquals("", File("aaa.").extension)
@@ -346,7 +346,7 @@ class FilesTest {
assertEquals("", File("/my.dir/log").extension)
}
@test fun nameWithoutExtension() {
@Test fun nameWithoutExtension() {
assertEquals("aaa", File("aaa.bbb").nameWithoutExtension)
assertEquals("aaa", File("aaa").nameWithoutExtension)
assertEquals("aaa", File("aaa.").nameWithoutExtension)
@@ -354,7 +354,7 @@ class FilesTest {
assertEquals("log", File("/my.dir/log").nameWithoutExtension)
}
@test fun testCopyTo() {
@Test fun testCopyTo() {
val srcFile = createTempFile()
val dstFile = createTempFile()
try {
@@ -419,7 +419,7 @@ class FilesTest {
}
}
@test fun copyToNameWithoutParent() {
@Test fun copyToNameWithoutParent() {
val currentDir = File("").absoluteFile!!
val srcFile = createTempFile()
val dstFile = createTempFile(directory = currentDir)
@@ -439,7 +439,7 @@ class FilesTest {
}
}
@test fun deleteRecursively() {
@Test fun deleteRecursively() {
val dir = createTempDir()
dir.delete()
dir.mkdir()
@@ -453,7 +453,7 @@ class FilesTest {
assertTrue(dir.deleteRecursively())
}
@test fun deleteRecursivelyWithFail() {
@Test fun deleteRecursivelyWithFail() {
val basedir = FileTreeWalkTest.createTestFiles()
val restricted = File(basedir, "1")
try {
@@ -491,7 +491,7 @@ class FilesTest {
}
}
@test fun copyRecursively() {
@Test fun copyRecursively() {
val src = createTempDir()
val dst = createTempDir()
dst.delete()
@@ -562,7 +562,7 @@ class FilesTest {
}
}
@test fun copyRecursivelyWithOverwrite() {
@Test fun copyRecursivelyWithOverwrite() {
val src = createTempDir()
val dst = createTempDir()
fun check() = compareDirectories(src, dst)
@@ -596,7 +596,7 @@ class FilesTest {
}
}
@test fun helpers1() {
@Test fun helpers1() {
val str = "123456789\n"
System.setIn(str.byteInputStream())
val reader = System.`in`.bufferedReader()
@@ -607,7 +607,7 @@ class FilesTest {
assertEquals('3', stringReader.read().toChar())
}
@test fun helpers2() {
@Test fun helpers2() {
val file = createTempFile()
val writer = file.printWriter()
val str1 = "Hello, world!"
libraries/stdlib/test/io/IOStreams.kt
+3 -3
View File
@@ -1,13 +1,13 @@
@file:kotlin.jvm.JvmVersion
package test.io
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
import java.io.Writer
import java.io.BufferedReader
class IOStreamsTest {
@test fun testGetStreamOfFile() {
@Test fun testGetStreamOfFile() {
val tmpFile = createTempFile()
var writer: Writer? = null
try {
@@ -27,7 +27,7 @@ class IOStreamsTest {
assertEquals("Hello, World!", act)
}
@test fun testInputStreamIterator() {
@Test fun testInputStreamIterator() {
val x = ByteArray(10) { it.toByte() }
val result = mutableListOf<Byte>()
libraries/stdlib/test/io/ReadWrite.kt
+10 -10
View File
@@ -1,7 +1,7 @@
@file:kotlin.jvm.JvmVersion
package test.io
import org.junit.Test as test
import org.junit.Test
import java.io.File
import kotlin.test.assertEquals
import java.io.Reader
@@ -14,7 +14,7 @@ import kotlin.test.assertTrue
fun sample(): Reader = StringReader("Hello\nWorld");
class ReadWriteTest {
@test fun testAppendText() {
@Test fun testAppendText() {
val file = File.createTempFile("temp", System.nanoTime().toString())
file.writeText("Hello\n")
file.appendText("World\n")
@@ -25,7 +25,7 @@ class ReadWriteTest {
file.deleteOnExit()
}
@test fun reader() {
@Test fun reader() {
val list = ArrayList<String>()
/* TODO would be nicer maybe to write this as
@@ -71,7 +71,7 @@ class ReadWriteTest {
assertEquals(2, c)
}
@test fun file() {
@Test fun file() {
val file = File.createTempFile("temp", System.nanoTime().toString())
val writer = file.outputStream().writer().buffered()
@@ -125,7 +125,7 @@ class ReadWriteTest {
@test fun testUse() {
@Test fun testUse() {
val list = ArrayList<String>()
val reader = sample().buffered()
@@ -142,7 +142,7 @@ class ReadWriteTest {
assertEquals(arrayListOf("Hello", "World"), list)
}
@test fun testPlatformNullUse() {
@Test fun testPlatformNullUse() {
fun <T> platformNull() = java.util.Collections.singleton(null as T).first()
val resource = platformNull<java.io.Closeable>()
val result = resource.use {
@@ -151,7 +151,7 @@ class ReadWriteTest {
assertEquals("ok", result)
}
@test fun testURL() {
@Test fun testURL() {
val url = URL("http://kotlinlang.org")
val text = url.readText()
assertFalse(text.isEmpty())
@@ -162,7 +162,7 @@ class ReadWriteTest {
class LineIteratorTest {
@test fun useLines() {
@Test fun useLines() {
// TODO we should maybe zap the useLines approach as it encourages
// use of iterators which don't close the underlying stream
val list1 = sample().useLines { it.toList() }
@@ -172,7 +172,7 @@ class LineIteratorTest {
assertEquals(listOf("Hello", "World"), list2)
}
@test fun manualClose() {
@Test fun manualClose() {
val reader = sample().buffered()
try {
val list = reader.lineSequence().toList()
@@ -182,7 +182,7 @@ class LineIteratorTest {
}
}
@test fun boundaryConditions() {
@Test fun boundaryConditions() {
var reader = StringReader("").buffered()
assertEquals(emptyList(), reader.lineSequence().toList())
reader.close()
libraries/stdlib/test/js/JsArrayTest.kt
+3 -3
View File
@@ -16,12 +16,12 @@
package test.collections.js
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
class JsArrayTest {
@test fun arraySizeAndToList() {
@Test fun arraySizeAndToList() {
val a1 = arrayOf<String>()
val a2 = arrayOf("foo")
val a3 = arrayOf("foo", "bar")
@@ -36,7 +36,7 @@ class JsArrayTest {
}
@test fun arrayListFromCollection() {
@Test fun arrayListFromCollection() {
var c: Collection<String> = arrayOf("A", "B", "C").toList()
var a = ArrayList(c)
libraries/stdlib/test/js/JsCollectionsTest.kt
+11 -11
View File
@@ -2,53 +2,53 @@ package test.collections.js
import kotlin.test.*
import kotlin.comparisons.*
import org.junit.Test as test
import org.junit.Test
class JsCollectionsTest {
val TEST_LIST = arrayOf(2, 0, 9, 7, 1).toList()
@test fun collectionToArray() {
@Test fun collectionToArray() {
val array = TEST_LIST.toTypedArray()
assertEquals(array.toList(), TEST_LIST)
}
@test fun toListDoesNotCreateArrayView() {
@Test fun toListDoesNotCreateArrayView() {
snapshotDoesNotCreateView(arrayOf("first", "last"), { it.toList() })
snapshotDoesNotCreateView(arrayOf<Any>("item", 1), { it.toList() })
}
@test fun toMutableListDoesNotCreateArrayView() {
@Test fun toMutableListDoesNotCreateArrayView() {
snapshotDoesNotCreateView(arrayOf("first", "last"), { it.toMutableList() })
snapshotDoesNotCreateView(arrayOf<Any>("item", 2), { it.toMutableList() })
}
@test fun listOfDoesNotCreateView() {
@Test fun listOfDoesNotCreateView() {
snapshotDoesNotCreateView(arrayOf("first", "last"), { listOf(*it) })
snapshotDoesNotCreateView(arrayOf<Any>("item", 3), { listOf(*it) })
}
@test fun mutableListOfDoesNotCreateView() {
@Test fun mutableListOfDoesNotCreateView() {
snapshotDoesNotCreateView(arrayOf("first", "last"), { mutableListOf(*it) })
snapshotDoesNotCreateView(arrayOf<Any>("item", 4), { mutableListOf(*it) })
}
@test fun arrayListDoesNotCreateArrayView() {
@Test fun arrayListDoesNotCreateArrayView() {
snapshotDoesNotCreateView(arrayOf(1, 2), { arrayListOf(*it) })
snapshotDoesNotCreateView(arrayOf<Any>("first", "last"), { arrayListOf(*it) })
}
@test fun arrayListCapacity() {
@Test fun arrayListCapacity() {
val list = ArrayList<Any>(20)
list.ensureCapacity(100)
list.trimToSize()
assertTrue(list.isEmpty())
}
@test fun listEqualsOperatesOnAny() {
@Test fun listEqualsOperatesOnAny() {
assertFalse(listOf(1, 2, 3).equals(object {}))
}
@test fun arrayListValidatesIndexRange() {
@Test fun arrayListValidatesIndexRange() {
val list = mutableListOf(1)
for (index in listOf(-1, 1, 3)) {
if (index != list.size) { // size is a valid position index
@@ -63,7 +63,7 @@ class JsCollectionsTest {
assertEquals(listOf(1), list)
}
@test fun mutableIteratorRemove() {
@Test fun mutableIteratorRemove() {
val a = mutableListOf(1, 2, 3)
val it = a.iterator()
assertFailsWith<IllegalStateException> { it.remove() }
libraries/stdlib/test/js/MapJsTest.kt
+37 -37
View File
@@ -1,7 +1,7 @@
package test.collections.js
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
import test.collections.*
import test.collections.behaviors.*
@@ -17,7 +17,7 @@ class ComplexMapJsTest : MapJsTest() {
assertEquals(VALUES.toNormalizedList(), map.values.toNormalizedList())
}
@test override fun constructors() {
@Test override fun constructors() {
doTest<String>()
}
@@ -28,7 +28,7 @@ class ComplexMapJsTest : MapJsTest() {
}
class PrimitiveMapJsTest : MapJsTest() {
@test override fun constructors() {
@Test override fun constructors() {
HashMap<String, Int>()
HashMap<String, Int>(3)
HashMap<String, Int>(3, 0.5f)
@@ -43,7 +43,7 @@ class PrimitiveMapJsTest : MapJsTest() {
override fun emptyMutableMap(): MutableMap<String, Int> = stringMapOf()
override fun emptyMutableMapWithNullableKeyValue(): MutableMap<String?, Int?> = HashMap()
@test fun compareBehavior() {
@Test fun compareBehavior() {
val specialJsStringMap = HashMap<String, Any>()
specialJsStringMap.put("k1", "v1")
compare(genericHashMapOf("k1" to "v1"), specialJsStringMap) { mapBehavior() }
@@ -55,7 +55,7 @@ class PrimitiveMapJsTest : MapJsTest() {
}
class LinkedHashMapJsTest : MapJsTest() {
@test override fun constructors() {
@Test override fun constructors() {
LinkedHashMap<String, Int>()
LinkedHashMap<String, Int>(3)
LinkedHashMap<String, Int>(3, 0.5f)
@@ -72,7 +72,7 @@ class LinkedHashMapJsTest : MapJsTest() {
}
class LinkedPrimitiveMapJsTest : MapJsTest() {
@test override fun constructors() {
@Test override fun constructors() {
val map = createTestMap()
assertEquals(KEYS.toNormalizedList(), map.keys.toNormalizedList())
@@ -90,7 +90,7 @@ abstract class MapJsTest {
val SPECIAL_NAMES = arrayOf("__proto__", "constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable")
@test fun getOrElse() {
@Test fun getOrElse() {
val data = emptyMap()
val a = data.getOrElse("foo"){2}
assertEquals(2, a)
@@ -100,7 +100,7 @@ abstract class MapJsTest {
assertEquals(0, data.size)
}
@test fun getOrPut() {
@Test fun getOrPut() {
val data = emptyMutableMap()
val a = data.getOrPut("foo"){2}
assertEquals(2, a)
@@ -111,13 +111,13 @@ abstract class MapJsTest {
assertEquals(1, data.size)
}
@test fun emptyMapGet() {
@Test fun emptyMapGet() {
val map = emptyMap()
assertEquals(null, map.get("foo"), """failed on map.get("foo")""")
assertEquals(null, map["bar"], """failed on map["bar"]""")
}
@test fun mapGet() {
@Test fun mapGet() {
val map = createTestMap()
for (i in KEYS.indices) {
assertEquals(VALUES[i], map.get(KEYS[i]), """failed on map.get(KEYS[$i])""")
@@ -127,7 +127,7 @@ abstract class MapJsTest {
assertEquals(null, map.get("foo"))
}
@test fun mapPut() {
@Test fun mapPut() {
val map = emptyMutableMap()
map.put("foo", 1)
@@ -143,7 +143,7 @@ abstract class MapJsTest {
assertEquals(2, map["bar"])
}
@test fun sizeAndEmptyForEmptyMap() {
@Test fun sizeAndEmptyForEmptyMap() {
val data = emptyMap()
assertTrue(data.isEmpty())
@@ -153,7 +153,7 @@ abstract class MapJsTest {
assertEquals(0, data.size)
}
@test fun sizeAndEmpty() {
@Test fun sizeAndEmpty() {
val data = createTestMap()
assertFalse(data.isEmpty())
@@ -163,22 +163,22 @@ abstract class MapJsTest {
}
// #KT-3035
@test fun emptyMapValues() {
@Test fun emptyMapValues() {
val emptyMap = emptyMap()
assertTrue(emptyMap.values.isEmpty())
}
@test fun mapValues() {
@Test fun mapValues() {
val map = createTestMap()
assertEquals(VALUES.toNormalizedList(), map.values.toNormalizedList())
}
@test fun mapKeySet() {
@Test fun mapKeySet() {
val map = createTestMap()
assertEquals(KEYS.toNormalizedList(), map.keys.toNormalizedList())
}
@test fun mapEntrySet() {
@Test fun mapEntrySet() {
val map = createTestMap()
val actualKeys = ArrayList<String>()
@@ -192,7 +192,7 @@ abstract class MapJsTest {
assertEquals(VALUES.toNormalizedList(), actualValues.toNormalizedList())
}
@test fun mapContainsKey() {
@Test fun mapContainsKey() {
val map = createTestMap()
assertTrue(map.containsKey(KEYS[0]) &&
@@ -204,7 +204,7 @@ abstract class MapJsTest {
map.containsKey(1 as Any))
}
@test fun mapContainsValue() {
@Test fun mapContainsValue() {
val map = createTestMap()
assertTrue(map.containsValue(VALUES[0]) &&
@@ -216,20 +216,20 @@ abstract class MapJsTest {
map.containsValue(5))
}
@test fun mapPutAll() {
@Test fun mapPutAll() {
val map = createTestMap()
val newMap = emptyMutableMap()
newMap.putAll(map)
assertEquals(KEYS.size, newMap.size)
}
@test fun mapPutAllFromCustomMap() {
@Test fun mapPutAllFromCustomMap() {
val newMap = emptyMutableMap()
newMap.putAll(ConstMap)
assertEquals(ConstMap.entries.single().toPair(), newMap.entries.single().toPair())
}
@test fun mapRemove() {
@Test fun mapRemove() {
val map = createTestMutableMap()
val last = KEYS.size - 1
val first = 0
@@ -246,14 +246,14 @@ abstract class MapJsTest {
assertEquals(KEYS.size - 3, map.size)
}
@test fun mapClear() {
@Test fun mapClear() {
val map = createTestMutableMap()
assertFalse(map.isEmpty())
map.clear()
assertTrue(map.isEmpty())
}
@test fun nullAsKey() {
@Test fun nullAsKey() {
val map = emptyMutableMapWithNullableKeyValue()
assertTrue(map.isEmpty())
@@ -266,7 +266,7 @@ abstract class MapJsTest {
assertEquals(null, map[null])
}
@test fun nullAsValue() {
@Test fun nullAsValue() {
val map = emptyMutableMapWithNullableKeyValue()
val KEY = "Key"
@@ -279,7 +279,7 @@ abstract class MapJsTest {
assertTrue(map.isEmpty())
}
@test fun setViaIndexOperators() {
@Test fun setViaIndexOperators() {
val map = HashMap<String, String>()
assertTrue{ map.isEmpty() }
assertEquals(map.size, 0)
@@ -291,21 +291,21 @@ abstract class MapJsTest {
assertEquals("James", map["name"])
}
@test fun createUsingPairs() {
@Test fun createUsingPairs() {
val map = mapOf(Pair("a", 1), Pair("b", 2))
assertEquals(2, map.size)
assertEquals(1, map.get("a"))
assertEquals(2, map.get("b"))
}
@test fun createUsingTo() {
@Test fun createUsingTo() {
val map = mapOf("a" to 1, "b" to 2)
assertEquals(2, map.size)
assertEquals(1, map.get("a"))
assertEquals(2, map.get("b"))
}
@test fun mapIteratorImplicitly() {
@Test fun mapIteratorImplicitly() {
val map = createTestMap()
val actualKeys = ArrayList<String>()
@@ -319,7 +319,7 @@ abstract class MapJsTest {
assertEquals(VALUES.toNormalizedList(), actualValues.toNormalizedList())
}
@test fun mapIteratorExplicitly() {
@Test fun mapIteratorExplicitly() {
val map = createTestMap()
val actualKeys = ArrayList<String>()
@@ -334,7 +334,7 @@ abstract class MapJsTest {
assertEquals(VALUES.toNormalizedList(), actualValues.toNormalizedList())
}
@test fun mapMutableIterator() {
@Test fun mapMutableIterator() {
val map = createTestMutableMap()
map.keys.removeAll { it == KEYS[0] }
map.entries.removeAll { it.key == KEYS[1] }
@@ -343,7 +343,7 @@ abstract class MapJsTest {
assertEquals(1, map.size, "Expected 1 entry to remain in map, but got: $map")
}
@test fun mapCollectionPropertiesAreViews() {
@Test fun mapCollectionPropertiesAreViews() {
val map = createTestMutableMap()
assertTrue(map.size >= 3)
val keys = map.keys
@@ -384,7 +384,7 @@ abstract class MapJsTest {
assertEquals(100, map[entry2.key], "set value via entry")
}
@test fun mapCollectionPropertiesDoNotSupportAdd() {
@Test fun mapCollectionPropertiesDoNotSupportAdd() {
val map = createTestMutableMap()
val entry = map.entries.first()
val (key, value) = entry
@@ -394,7 +394,7 @@ abstract class MapJsTest {
assertFailsWith<UnsupportedOperationException> { map.values += value }
}
@test fun specialNamesNotContainsInEmptyMap() {
@Test fun specialNamesNotContainsInEmptyMap() {
val map = emptyMap()
for (key in SPECIAL_NAMES) {
@@ -402,7 +402,7 @@ abstract class MapJsTest {
}
}
@test fun specialNamesNotContainsInNonEmptyMap() {
@Test fun specialNamesNotContainsInNonEmptyMap() {
val map = createTestMap()
for (key in SPECIAL_NAMES) {
@@ -410,7 +410,7 @@ abstract class MapJsTest {
}
}
@test fun putAndGetSpecialNamesToMap() {
@Test fun putAndGetSpecialNamesToMap() {
val map = createTestMutableMap()
var value = 0
@@ -430,7 +430,7 @@ abstract class MapJsTest {
}
}
@test abstract fun constructors()
@Test abstract fun constructors()
/*
test fun createLinkedMap() {
libraries/stdlib/test/language/EscapedTestNamesTest.kt
+3 -3
View File
@@ -1,17 +1,17 @@
@file:kotlin.jvm.JvmVersion // TODO: Can't run in JS: spaces in function name KT-4160
package test.language
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
class EscapedTestNamesTest {
@test fun `strings equal`() {
@Test fun `strings equal`() {
val actual = "abc"
assertEquals("abc", actual)
}
@test fun `numbers equal`() {
@Test fun `numbers equal`() {
val actual = 5
assertEquals(5, actual)
}
libraries/stdlib/test/numbers/BitwiseOperationsTest.kt
+8 -8
View File
@@ -1,35 +1,35 @@
package test.numbers
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
// TODO: Run these tests during compiler test only (JVM & JS)
class BitwiseOperationsTest {
@test fun orForInt() {
@Test fun orForInt() {
assertEquals(3, 2 or 1)
}
@test fun andForInt() {
@Test fun andForInt() {
assertEquals(0, 1 and 0)
}
@test fun xorForInt() {
@Test fun xorForInt() {
assertEquals(1, 2 xor 3)
}
@test fun shlForInt() {
@Test fun shlForInt() {
assertEquals(4, 1 shl 2)
}
@test fun shrForInt() {
@Test fun shrForInt() {
assertEquals(1, 2 shr 1)
}
@test fun ushrForInt() {
@Test fun ushrForInt() {
assertEquals(2147483647, -1 ushr 1)
}
@test fun invForInt() {
@Test fun invForInt() {
assertEquals(0, (-1).inv())
}
}
libraries/stdlib/test/numbers/CompanionIntrinsicObjectsJVMTest.kt
+9 -9
View File
@@ -19,17 +19,17 @@ package test.numbers
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class CompanionIntrinsicObjectsJVMTest {
@test fun intTest() {
@Test fun intTest() {
val i = Int
assertEquals(java.lang.Integer.MAX_VALUE, Int.MAX_VALUE)
assertEquals(java.lang.Integer.MIN_VALUE, Int.MIN_VALUE)
}
@test fun doubleTest() {
@Test fun doubleTest() {
val d = Double
assertEquals(java.lang.Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)
@@ -40,7 +40,7 @@ class CompanionIntrinsicObjectsJVMTest {
assertEquals(java.lang.Double.MIN_VALUE, Double.MIN_VALUE)
}
@test fun floatTest() {
@Test fun floatTest() {
val f = Float
assertEquals(java.lang.Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY)
@@ -51,34 +51,34 @@ class CompanionIntrinsicObjectsJVMTest {
assertEquals(java.lang.Float.MIN_VALUE, Float.MIN_VALUE)
}
@test fun longTest() {
@Test fun longTest() {
val l = Long
assertEquals(java.lang.Long.MAX_VALUE, Long.MAX_VALUE)
assertEquals(java.lang.Long.MIN_VALUE, Long.MIN_VALUE)
}
@test fun shortTest() {
@Test fun shortTest() {
val s = Short
assertEquals(java.lang.Short.MAX_VALUE, Short.MAX_VALUE)
assertEquals(java.lang.Short.MIN_VALUE, Short.MIN_VALUE)
}
@test fun byteTest() {
@Test fun byteTest() {
val b = Byte
assertEquals(java.lang.Byte.MAX_VALUE, Byte.MAX_VALUE)
assertEquals(java.lang.Byte.MIN_VALUE, Byte.MIN_VALUE)
}
@test fun charTest() {
@Test fun charTest() {
val ch = Char
assertEquals(ch, Char)
}
@test fun stringTest() {
@Test fun stringTest() {
val s = String
assertEquals(s, String)
libraries/stdlib/test/numbers/MathJVMTest.kt
+3 -3
View File
@@ -5,10 +5,10 @@ import java.math.BigInteger
import java.math.BigDecimal
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class MathTest {
@test fun testBigInteger() {
@Test fun testBigInteger() {
val a = BigInteger("2")
val b = BigInteger("3")
@@ -21,7 +21,7 @@ class MathTest {
assertEquals(BigInteger("-2"), (-a).remainder(b))
}
@test fun testBigDecimal() {
@Test fun testBigDecimal() {
val a = BigDecimal("2")
val b = BigDecimal("3")
libraries/stdlib/test/numbers/NumbersJVMTest.kt
+8 -8
View File
@@ -2,46 +2,46 @@
package test.numbers
import java.math.BigDecimal
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
class NumbersJVMTest {
@test fun intMinMaxValues() {
@Test fun intMinMaxValues() {
assertEquals(java.lang.Integer.MIN_VALUE, Int.MIN_VALUE)
assertEquals(java.lang.Integer.MAX_VALUE, Int.MAX_VALUE)
}
@test fun longMinMaxValues() {
@Test fun longMinMaxValues() {
assertEquals(java.lang.Long.MIN_VALUE, Long.MIN_VALUE)
assertEquals(java.lang.Long.MAX_VALUE, Long.MAX_VALUE)
}
@test fun shortMinMaxValues() {
@Test fun shortMinMaxValues() {
assertEquals(java.lang.Short.MIN_VALUE, Short.MIN_VALUE)
assertEquals(java.lang.Short.MAX_VALUE, Short.MAX_VALUE)
}
@test fun byteMinMaxValues() {
@Test fun byteMinMaxValues() {
assertEquals(java.lang.Byte.MIN_VALUE, Byte.MIN_VALUE)
assertEquals(java.lang.Byte.MAX_VALUE, Byte.MAX_VALUE)
}
@test fun doubleMinMaxValues() {
@Test fun doubleMinMaxValues() {
assertEquals(java.lang.Double.MIN_VALUE, Double.MIN_VALUE)
assertEquals(java.lang.Double.MAX_VALUE, Double.MAX_VALUE)
assertEquals(java.lang.Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY)
assertEquals(java.lang.Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY)
}
@test fun floatMinMaxValues() {
@Test fun floatMinMaxValues() {
assertEquals(java.lang.Float.MIN_VALUE, Float.MIN_VALUE)
assertEquals(java.lang.Float.MAX_VALUE, Float.MAX_VALUE)
assertEquals(java.lang.Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY)
assertEquals(java.lang.Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY)
}
@test fun bigDecimalDivRounding() {
@Test fun bigDecimalDivRounding() {
val (d1, d2, d3, d4, d5) = (1..5).map { BigDecimal(it.toString()) }
val d7 = BigDecimal("7")
libraries/stdlib/test/numbers/NumbersTest.kt
+9 -9
View File
@@ -1,6 +1,6 @@
package test.numbers
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
object NumbersTestConstants {
@@ -21,7 +21,7 @@ class NumbersTest {
var one: Int = 1
@test fun intMinMaxValues() {
@Test fun intMinMaxValues() {
assertTrue(Int.MIN_VALUE < 0)
assertTrue(Int.MAX_VALUE > 0)
@@ -34,7 +34,7 @@ class NumbersTest {
// expect(Int.MAX_VALUE) { Int.MIN_VALUE - 1 }
}
@test fun longMinMaxValues() {
@Test fun longMinMaxValues() {
assertTrue(Long.MIN_VALUE < 0)
assertTrue(Long.MAX_VALUE > 0)
@@ -46,7 +46,7 @@ class NumbersTest {
expect(Long.MAX_VALUE) { Long.MIN_VALUE - 1 }
}
@test fun shortMinMaxValues() {
@Test fun shortMinMaxValues() {
assertTrue(Short.MIN_VALUE < 0)
assertTrue(Short.MAX_VALUE > 0)
@@ -58,7 +58,7 @@ class NumbersTest {
expect(Short.MAX_VALUE) { (Short.MIN_VALUE - 1).toShort() }
}
@test fun byteMinMaxValues() {
@Test fun byteMinMaxValues() {
assertTrue(Byte.MIN_VALUE < 0)
assertTrue(Byte.MAX_VALUE > 0)
@@ -70,7 +70,7 @@ class NumbersTest {
expect(Byte.MAX_VALUE) { (Byte.MIN_VALUE - 1).toByte() }
}
@test fun doubleMinMaxValues() {
@Test fun doubleMinMaxValues() {
assertTrue(Double.MIN_VALUE > 0)
assertTrue(Double.MAX_VALUE > 0)
@@ -80,7 +80,7 @@ class NumbersTest {
expect(0.0) { Double.MIN_VALUE / 2 }
}
@test fun floatMinMaxValues() {
@Test fun floatMinMaxValues() {
assertTrue(Float.MIN_VALUE > 0)
assertTrue(Float.MAX_VALUE > 0)
@@ -90,7 +90,7 @@ class NumbersTest {
expect(0.0F) { Float.MIN_VALUE / 2.0F }
}
@test fun doubleProperties() {
@Test fun doubleProperties() {
for (value in listOf(1.0, 0.0, Double.MIN_VALUE, Double.MAX_VALUE))
doTestNumber(value)
for (value in listOf(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY))
@@ -98,7 +98,7 @@ class NumbersTest {
doTestNumber(Double.NaN, isNaN = true)
}
@test fun floatProperties() {
@Test fun floatProperties() {
for (value in listOf(1.0F, 0.0F, Float.MAX_VALUE, Float.MIN_VALUE))
doTestNumber(value)
for (value in listOf(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY))
libraries/stdlib/test/properties/delegation/DelegationTest.kt
+4 -4
View File
@@ -1,11 +1,11 @@
package test.properties.delegation
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
import kotlin.properties.*
class NotNullVarTest() {
@test fun doTest() {
@Test fun doTest() {
NotNullVarTestGeneric("a", "b").doTest()
}
}
@@ -31,7 +31,7 @@ class ObservablePropertyTest {
assertEquals(new, b, "New value has already been set")
})
@test fun doTest() {
@Test fun doTest() {
b = 4
assertTrue(b == 4, "fail: b != 4")
assertTrue(result, "fail: result should be true")
@@ -49,7 +49,7 @@ class VetoablePropertyTest {
result
})
@test fun doTest() {
@Test fun doTest() {
val firstValue = A(true)
b = firstValue
assertTrue(b == firstValue, "fail1: b should be firstValue = A(true)")
libraries/stdlib/test/properties/delegation/MapAccessorsTest.kt
+3 -3
View File
@@ -1,7 +1,7 @@
package test.properties.delegation.map
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class ValByMapExtensionsTest {
val map: Map<String, String> = hashMapOf("a" to "all", "b" to "bar", "c" to "code")
@@ -18,7 +18,7 @@ class ValByMapExtensionsTest {
val x: Double by genericMap
@test fun doTest() {
@Test fun doTest() {
assertEquals("all", a)
assertEquals("bar", b)
assertEquals("code", c)
@@ -43,7 +43,7 @@ class VarByMapExtensionsTest {
var a2: String by map2.withDefault { "empty" }
//var x: Int by map2 // prohibited by type system
@test fun doTest() {
@Test fun doTest() {
assertEquals("all", a)
assertEquals(null, b)
assertEquals(1, c)
libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt
+7 -7
View File
@@ -1,6 +1,6 @@
package test.properties.delegation.lazy
import org.junit.Test as test
import org.junit.Test
import kotlin.properties.*
import kotlin.test.*
@@ -10,7 +10,7 @@ class LazyValTest {
++result
}
@test fun doTest() {
@Test fun doTest() {
a
assertTrue(a == 1, "fail: initializer should be invoked only once")
}
@@ -23,7 +23,7 @@ class SynchronizedLazyValTest {
++result
}
@test fun doTest() {
@Test fun doTest() {
synchronized(this) {
kotlin.concurrent.thread { a } // not available in js
result = 1
@@ -40,7 +40,7 @@ class UnsafeLazyValTest {
++result
}
@test fun doTest() {
@Test fun doTest() {
a
assertTrue(a == 1, "fail: initializer should be invoked only once")
}
@@ -53,7 +53,7 @@ class NullableLazyValTest {
val a: Int? by lazy { resultA++; null}
val b by lazy { foo() }
@test fun doTest() {
@Test fun doTest() {
a
b
@@ -76,7 +76,7 @@ class UnsafeNullableLazyValTest {
val a: Int? by lazy(LazyThreadSafetyMode.NONE) { resultA++; null}
val b by lazy(LazyThreadSafetyMode.NONE) { foo() }
@test fun doTest() {
@Test fun doTest() {
a
b
@@ -96,7 +96,7 @@ class IdentityEqualsIsUsedToUnescapeLazyValTest {
var equalsCalled = 0
private val a by lazy { ClassWithCustomEquality { equalsCalled++ } }
@test fun doTest() {
@Test fun doTest() {
a
a
assertTrue(equalsCalled == 0, "fail: equals called $equalsCalled times.")
libraries/stdlib/test/ranges/CoercionTest.kt
-1
View File
@@ -1,7 +1,6 @@
package test.ranges
import org.junit.Test
import org.junit.Test as test
import kotlin.test.*
class CoercionTest {
libraries/stdlib/test/ranges/RangeIterationJVMTest.kt
+11 -11
View File
@@ -11,14 +11,14 @@ import java.lang.Long.MAX_VALUE as MaxL
import java.lang.Long.MIN_VALUE as MinL
import java.lang.Character.MAX_VALUE as MaxC
import java.lang.Character.MIN_VALUE as MinC
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
// Test data for codegen is generated from this class. If you change it, rerun GenerateTests
public class RangeIterationJVMTest : RangeIterationTestBase() {
@test fun maxValueToMaxValue() {
@Test fun maxValueToMaxValue() {
doTest(MaxI..MaxI, MaxI, MaxI, 1, listOf(MaxI))
doTest(MaxB..MaxB, MaxB.toInt(), MaxB.toInt(), 1, listOf(MaxB.toInt()))
doTest(MaxS..MaxS, MaxS.toInt(), MaxS.toInt(), 1, listOf(MaxS.toInt()))
@@ -27,7 +27,7 @@ public class RangeIterationJVMTest : RangeIterationTestBase() {
doTest(MaxC..MaxC, MaxC, MaxC, 1, listOf(MaxC))
}
@test fun maxValueMinusTwoToMaxValue() {
@Test fun maxValueMinusTwoToMaxValue() {
doTest((MaxI - 2)..MaxI, MaxI - 2, MaxI, 1, listOf(MaxI - 2, MaxI - 1, MaxI))
doTest((MaxB - 2).toByte()..MaxB, (MaxB - 2).toInt(), MaxB.toInt(), 1, listOf((MaxB - 2).toInt(), (MaxB - 1).toInt(), MaxB.toInt()))
doTest((MaxS - 2).toShort()..MaxS, (MaxS - 2).toInt(), MaxS.toInt(), 1, listOf((MaxS - 2).toInt(), (MaxS - 1).toInt(), MaxS.toInt()))
@@ -36,7 +36,7 @@ public class RangeIterationJVMTest : RangeIterationTestBase() {
doTest((MaxC - 2)..MaxC, (MaxC - 2), MaxC, 1, listOf((MaxC - 2), (MaxC - 1), MaxC))
}
@test fun maxValueToMinValue() {
@Test fun maxValueToMinValue() {
doTest(MaxI..MinI, MaxI, MinI, 1, listOf())
doTest(MaxB..MinB, MaxB.toInt(), MinB.toInt(), 1, listOf())
doTest(MaxS..MinS, MaxS.toInt(), MinS.toInt(), 1, listOf())
@@ -45,7 +45,7 @@ public class RangeIterationJVMTest : RangeIterationTestBase() {
doTest(MaxC..MinC, MaxC, MinC, 1, listOf())
}
@test fun progressionMaxValueToMaxValue() {
@Test fun progressionMaxValueToMaxValue() {
doTest(MaxI..MaxI step 1, MaxI, MaxI, 1, listOf(MaxI))
doTest(MaxB..MaxB step 1, MaxB.toInt(), MaxB.toInt(), 1, listOf(MaxB.toInt()))
doTest(MaxS..MaxS step 1, MaxS.toInt(), MaxS.toInt(), 1, listOf(MaxS.toInt()))
@@ -54,7 +54,7 @@ public class RangeIterationJVMTest : RangeIterationTestBase() {
doTest(MaxC..MaxC step 1, MaxC, MaxC, 1, listOf(MaxC))
}
@test fun progressionMaxValueMinusTwoToMaxValue() {
@Test fun progressionMaxValueMinusTwoToMaxValue() {
doTest((MaxI - 2)..MaxI step 2, MaxI - 2, MaxI, 2, listOf(MaxI - 2, MaxI))
doTest((MaxB - 2).toByte()..MaxB step 2, (MaxB - 2).toInt(), MaxB.toInt(), 2, listOf((MaxB - 2).toInt(), MaxB.toInt()))
doTest((MaxS - 2).toShort()..MaxS step 2, (MaxS - 2).toInt(), MaxS.toInt(), 2, listOf((MaxS - 2).toInt(), MaxS.toInt()))
@@ -63,7 +63,7 @@ public class RangeIterationJVMTest : RangeIterationTestBase() {
doTest((MaxC - 2)..MaxC step 2, (MaxC - 2), MaxC, 2, listOf((MaxC - 2), MaxC))
}
@test fun progressionMaxValueToMinValue() {
@Test fun progressionMaxValueToMinValue() {
doTest(MaxI..MinI step 1, MaxI, MinI, 1, listOf())
doTest(MaxB..MinB step 1, MaxB.toInt(), MinB.toInt(), 1, listOf())
doTest(MaxS..MinS step 1, MaxS.toInt(), MinS.toInt(), 1, listOf())
@@ -72,7 +72,7 @@ public class RangeIterationJVMTest : RangeIterationTestBase() {
doTest(MaxC..MinC step 1, MaxC, MinC, 1, listOf())
}
@test fun progressionMinValueToMinValue() {
@Test fun progressionMinValueToMinValue() {
doTest(MinI..MinI step 1, MinI, MinI, 1, listOf(MinI))
doTest(MinB..MinB step 1, MinB.toInt(), MinB.toInt(), 1, listOf(MinB.toInt()))
doTest(MinS..MinS step 1, MinS.toInt(), MinS.toInt(), 1, listOf(MinS.toInt()))
@@ -81,7 +81,7 @@ public class RangeIterationJVMTest : RangeIterationTestBase() {
doTest(MinC..MinC step 1, MinC, MinC, 1, listOf(MinC))
}
@test fun inexactToMaxValue() {
@Test fun inexactToMaxValue() {
doTest((MaxI - 5)..MaxI step 3, MaxI - 5, MaxI - 2, 3, listOf(MaxI - 5, MaxI - 2))
doTest((MaxB - 5).toByte()..MaxB step 3, (MaxB - 5).toInt(), (MaxB - 2).toInt(), 3, listOf((MaxB - 5).toInt(), (MaxB - 2).toInt()))
doTest((MaxS - 5).toShort()..MaxS step 3, (MaxS - 5).toInt(), (MaxS - 2).toInt(), 3, listOf((MaxS - 5).toInt(), (MaxS - 2).toInt()))
@@ -90,7 +90,7 @@ public class RangeIterationJVMTest : RangeIterationTestBase() {
doTest((MaxC - 5)..MaxC step 3, (MaxC - 5), (MaxC - 2), 3, listOf((MaxC - 5), (MaxC - 2)))
}
@test fun progressionDownToMinValue() {
@Test fun progressionDownToMinValue() {
doTest((MinI + 2) downTo MinI step 1, MinI + 2, MinI, -1, listOf(MinI + 2, MinI + 1, MinI))
doTest((MinB + 2).toByte() downTo MinB step 1, (MinB + 2).toInt(), MinB.toInt(), -1, listOf((MinB + 2).toInt(), (MinB + 1).toInt(), MinB.toInt()))
doTest((MinS + 2).toShort() downTo MinS step 1, (MinS + 2).toInt(), MinS.toInt(), -1, listOf((MinS + 2).toInt(), (MinS + 1).toInt(), MinS.toInt()))
@@ -99,7 +99,7 @@ public class RangeIterationJVMTest : RangeIterationTestBase() {
doTest((MinC + 2) downTo MinC step 1, (MinC + 2), MinC, -1, listOf((MinC + 2), (MinC + 1), MinC))
}
@test fun inexactDownToMinValue() {
@Test fun inexactDownToMinValue() {
doTest((MinI + 5) downTo MinI step 3, MinI + 5, MinI + 2, -3, listOf(MinI + 5, MinI + 2))
doTest((MinB + 5).toByte() downTo MinB step 3, (MinB + 5).toInt(), (MinB + 2).toInt(), -3, listOf((MinB + 5).toInt(), (MinB + 2).toInt()))
doTest((MinS + 5).toShort() downTo MinS step 3, (MinS + 5).toInt(), (MinS + 2).toInt(), -3, listOf((MinS + 5).toInt(), (MinS + 2).toInt()))
libraries/stdlib/test/ranges/RangeIterationTest.kt
+20 -20
View File
@@ -1,6 +1,6 @@
package test.ranges
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
public open class RangeIterationTestBase {
@@ -48,14 +48,14 @@ public open class RangeIterationTestBase {
// Test data for codegen is generated from this class. If you change it, rerun GenerateTests
public class RangeIterationTest : RangeIterationTestBase() {
@test fun emptyConstant() {
@Test fun emptyConstant() {
doTest(IntRange.EMPTY, 1, 0, 1, listOf())
doTest(LongRange.EMPTY, 1.toLong(), 0.toLong(), 1.toLong(), listOf())
doTest(CharRange.EMPTY, 1.toChar(), 0.toChar(), 1, listOf())
}
@test fun emptyRange() {
@Test fun emptyRange() {
doTest(10..5, 10, 5, 1, listOf())
doTest(10.toByte()..(-5).toByte(), 10, (-5), 1, listOf())
doTest(10.toShort()..(-5).toShort(), 10, (-5), 1, listOf())
@@ -64,7 +64,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
doTest('z'..'a', 'z', 'a', 1, listOf())
}
@test fun oneElementRange() {
@Test fun oneElementRange() {
doTest(5..5, 5, 5, 1, listOf(5))
doTest(5.toByte()..5.toByte(), 5, 5, 1, listOf(5))
doTest(5.toShort()..5.toShort(), 5, 5, 1, listOf(5))
@@ -73,7 +73,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
doTest('k'..'k', 'k', 'k', 1, listOf('k'))
}
@test fun simpleRange() {
@Test fun simpleRange() {
doTest(3..9, 3, 9, 1, listOf(3, 4, 5, 6, 7, 8, 9))
doTest(3.toByte()..9.toByte(), 3, 9, 1, listOf(3, 4, 5, 6, 7, 8, 9))
doTest(3.toShort()..9.toShort(), 3, 9, 1, listOf(3, 4, 5, 6, 7, 8, 9))
@@ -83,7 +83,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
}
@test fun simpleRangeWithNonConstantEnds() {
@Test fun simpleRangeWithNonConstantEnds() {
doTest((1 + 2)..(10 - 1), 3, 9, 1, listOf(3, 4, 5, 6, 7, 8, 9))
doTest((1.toByte() + 2.toByte()).toByte()..(10.toByte() - 1.toByte()).toByte(), 3, 9, 1, listOf(3, 4, 5, 6, 7, 8, 9))
doTest((1.toShort() + 2.toShort()).toShort()..(10.toShort() - 1.toShort()).toShort(), 3, 9, 1, listOf(3, 4, 5, 6, 7, 8, 9))
@@ -92,7 +92,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
doTest(("ace"[1])..("age"[1]), 'c', 'g', 1, listOf('c', 'd', 'e', 'f', 'g'))
}
@test fun openRange() {
@Test fun openRange() {
doTest(1 until 5, 1, 4, 1, listOf(1, 2, 3, 4))
doTest(1.toByte() until 5.toByte(), 1, 4, 1, listOf(1, 2, 3, 4))
doTest(1.toShort() until 5.toShort(), 1, 4, 1, listOf(1, 2, 3, 4))
@@ -101,7 +101,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
}
@test fun emptyDownto() {
@Test fun emptyDownto() {
doTest(5 downTo 10, 5, 10, -1, listOf())
doTest(5.toByte() downTo 10.toByte(), 5, 10, -1, listOf())
doTest(5.toShort() downTo 10.toShort(), 5, 10, -1, listOf())
@@ -110,7 +110,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
doTest('a' downTo 'z', 'a', 'z', -1, listOf())
}
@test fun oneElementDownTo() {
@Test fun oneElementDownTo() {
doTest(5 downTo 5, 5, 5, -1, listOf(5))
doTest(5.toByte() downTo 5.toByte(), 5, 5, -1, listOf(5))
doTest(5.toShort() downTo 5.toShort(), 5, 5, -1, listOf(5))
@@ -119,7 +119,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
doTest('k' downTo 'k', 'k', 'k', -1, listOf('k'))
}
@test fun simpleDownTo() {
@Test fun simpleDownTo() {
doTest(9 downTo 3, 9, 3, -1, listOf(9, 8, 7, 6, 5, 4, 3))
doTest(9.toByte() downTo 3.toByte(), 9, 3, -1, listOf(9, 8, 7, 6, 5, 4, 3))
doTest(9.toShort() downTo 3.toShort(), 9, 3, -1, listOf(9, 8, 7, 6, 5, 4, 3))
@@ -129,7 +129,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
}
@test fun simpleSteppedRange() {
@Test fun simpleSteppedRange() {
doTest(3..9 step 2, 3, 9, 2, listOf(3, 5, 7, 9))
doTest(3.toByte()..9.toByte() step 2, 3, 9, 2, listOf(3, 5, 7, 9))
doTest(3.toShort()..9.toShort() step 2, 3, 9, 2, listOf(3, 5, 7, 9))
@@ -138,7 +138,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
doTest('c'..'g' step 2, 'c', 'g', 2, listOf('c', 'e', 'g'))
}
@test fun simpleSteppedDownTo() {
@Test fun simpleSteppedDownTo() {
doTest(9 downTo 3 step 2, 9, 3, -2, listOf(9, 7, 5, 3))
doTest(9.toByte() downTo 3.toByte() step 2, 9, 3, -2, listOf(9, 7, 5, 3))
doTest(9.toShort() downTo 3.toShort() step 2, 9, 3, -2, listOf(9, 7, 5, 3))
@@ -149,7 +149,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
// 'inexact' means last element is not equal to sequence end
@test fun inexactSteppedRange() {
@Test fun inexactSteppedRange() {
doTest(3..8 step 2, 3, 7, 2, listOf(3, 5, 7))
doTest(3.toByte()..8.toByte() step 2, 3, 7, 2, listOf(3, 5, 7))
doTest(3.toShort()..8.toShort() step 2, 3, 7, 2, listOf(3, 5, 7))
@@ -159,7 +159,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
}
// 'inexact' means last element is not equal to sequence end
@test fun inexactSteppedDownTo() {
@Test fun inexactSteppedDownTo() {
doTest(8 downTo 3 step 2, 8, 4, -2, listOf(8, 6, 4))
doTest(8.toByte() downTo 3.toByte() step 2, 8, 4, -2, listOf(8, 6, 4))
doTest(8.toShort() downTo 3.toShort() step 2, 8, 4, -2, listOf(8, 6, 4))
@@ -169,7 +169,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
}
@test fun reversedEmptyRange() {
@Test fun reversedEmptyRange() {
doTest((5..3).reversed(), 3, 5, -1, listOf())
doTest((5.toByte()..3.toByte()).reversed(), 3, 5, -1, listOf())
doTest((5.toShort()..3.toShort()).reversed(), 3, 5, -1, listOf())
@@ -178,7 +178,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
doTest(('c'..'a').reversed(), 'a', 'c', -1, listOf())
}
@test fun reversedEmptyBackSequence() {
@Test fun reversedEmptyBackSequence() {
doTest((3 downTo 5).reversed(), 5, 3, 1, listOf())
doTest((3.toByte() downTo 5.toByte()).reversed(), 5, 3, 1, listOf())
doTest((3.toShort() downTo 5.toShort()).reversed(), 5, 3, 1, listOf())
@@ -187,7 +187,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
doTest(('a' downTo 'c').reversed(), 'c', 'a', 1, listOf())
}
@test fun reversedRange() {
@Test fun reversedRange() {
doTest((3..5).reversed(), 5, 3, -1, listOf(5, 4, 3))
doTest((3.toByte()..5.toByte()).reversed(),5, 3, -1, listOf(5, 4, 3))
doTest((3.toShort()..5.toShort()).reversed(), 5, 3, -1, listOf(5, 4, 3))
@@ -196,7 +196,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
doTest(('a'..'c').reversed(), 'c', 'a', -1, listOf('c', 'b', 'a'))
}
@test fun reversedBackSequence() {
@Test fun reversedBackSequence() {
doTest((5 downTo 3).reversed(), 3, 5, 1, listOf(3, 4, 5))
doTest((5.toByte() downTo 3.toByte()).reversed(), 3, 5, 1, listOf(3, 4, 5))
doTest((5.toShort() downTo 3.toShort()).reversed(), 3, 5, 1, listOf(3, 4, 5))
@@ -206,7 +206,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
}
@test fun reversedSimpleSteppedRange() {
@Test fun reversedSimpleSteppedRange() {
doTest((3..9 step 2).reversed(), 9, 3, -2, listOf(9, 7, 5, 3))
doTest((3.toByte()..9.toByte() step 2).reversed(), 9, 3, -2, listOf(9, 7, 5, 3))
doTest((3.toShort()..9.toShort() step 2).reversed(), 9, 3, -2, listOf(9, 7, 5, 3))
@@ -217,7 +217,7 @@ public class RangeIterationTest : RangeIterationTestBase() {
// invariant progression.reversed().toList() == progression.toList().reversed() is preserved
// 'inexact' means that start of reversed progression is not the end of original progression, but the last element
@test fun reversedInexactSteppedDownTo() {
@Test fun reversedInexactSteppedDownTo() {
doTest((8 downTo 3 step 2).reversed(), 4, 8, 2, listOf(4, 6, 8))
doTest((8.toByte() downTo 3.toByte() step 2).reversed(), 4, 8, 2, listOf(4, 6, 8))
doTest((8.toShort() downTo 3.toShort() step 2).reversed(), 4, 8, 2, listOf(4, 6, 8))
libraries/stdlib/test/ranges/RangeJVMTest.kt
+4 -4
View File
@@ -3,19 +3,19 @@ package test.ranges
import java.lang.Double as jDouble
import java.lang.Float as jFloat
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
public class RangeJVMTest {
@test fun doubleRange() {
@Test fun doubleRange() {
val range = -1.0..3.14159265358979
assertFalse(jDouble.NEGATIVE_INFINITY in range)
assertFalse(jDouble.POSITIVE_INFINITY in range)
assertFalse(jDouble.NaN in range)
}
@test fun floatRange() {
@Test fun floatRange() {
val range = -1.0f..3.14159f
assertFalse(jFloat.NEGATIVE_INFINITY in range)
assertFalse(jFloat.POSITIVE_INFINITY in range)
@@ -23,7 +23,7 @@ public class RangeJVMTest {
assertFalse(jFloat.NaN in range)
}
@test fun illegalProgressionCreation() {
@Test fun illegalProgressionCreation() {
fun assertFailsWithIllegalArgument(f: () -> Unit) = assertFailsWith(IllegalArgumentException::class, block = f)
// create Progression explicitly with increment = 0
assertFailsWithIllegalArgument { IntProgression.fromClosedRange(0, 5, 0) }
libraries/stdlib/test/ranges/RangeTest.kt
+12 -12
View File
@@ -1,10 +1,10 @@
package test.ranges
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
public class RangeTest {
@test fun intRange() {
@Test fun intRange() {
val range = -5..9
assertFalse(-1000 in range)
assertFalse(-6 in range)
@@ -39,7 +39,7 @@ public class RangeTest {
assertTrue((1 until Int.MIN_VALUE).isEmpty())
}
@test fun byteRange() {
@Test fun byteRange() {
val range = (-5).toByte()..9.toByte()
assertFalse((-100).toByte() in range)
assertFalse((-6).toByte() in range)
@@ -74,7 +74,7 @@ public class RangeTest {
assertTrue((0.toByte() until Int.MIN_VALUE).isEmpty())
}
@test fun shortRange() {
@Test fun shortRange() {
val range = (-5).toShort()..9.toShort()
assertFalse((-1000).toShort() in range)
assertFalse((-6).toShort() in range)
@@ -108,7 +108,7 @@ public class RangeTest {
assertTrue((0.toShort() until Int.MIN_VALUE).isEmpty())
}
@test fun longRange() {
@Test fun longRange() {
val range = -5L..9L
assertFalse(-10000000L in range)
assertFalse(-6L in range)
@@ -145,7 +145,7 @@ public class RangeTest {
}
@test fun charRange() {
@Test fun charRange() {
val range = 'c'..'w'
assertFalse('0' in range)
assertFalse('b' in range)
@@ -172,7 +172,7 @@ public class RangeTest {
assertTrue(('A' until '\u0000').isEmpty())
}
@test fun doubleRange() {
@Test fun doubleRange() {
val range = -1.0..3.14159265358979
assertFalse(-1e200 in range)
assertFalse(-100.0 in range)
@@ -198,7 +198,7 @@ public class RangeTest {
assertTrue(1.toFloat() in range)
}
@test fun floatRange() {
@Test fun floatRange() {
val range = -1.0f..3.14159f
assertFalse(-1e30f in range)
assertFalse(-100.0f in range)
@@ -226,7 +226,7 @@ public class RangeTest {
assertFalse(Double.MAX_VALUE in range)
}
@test fun isEmpty() {
@Test fun isEmpty() {
assertTrue((2..1).isEmpty())
assertTrue((2L..0L).isEmpty())
assertTrue((1.toShort()..-1.toShort()).isEmpty())
@@ -245,7 +245,7 @@ public class RangeTest {
assertTrue(("range".."progression").isEmpty())
}
@test fun emptyEquals() {
@Test fun emptyEquals() {
assertTrue(IntRange.EMPTY == IntRange.EMPTY)
assertEquals(IntRange.EMPTY, IntRange.EMPTY)
assertEquals(0L..42L, 0L..42L)
@@ -270,7 +270,7 @@ public class RangeTest {
assertFalse(("aa".."bb") == ("aaa".."bbb"))
}
@test fun emptyHashCode() {
@Test fun emptyHashCode() {
assertEquals((0..42).hashCode(), (0..42).hashCode())
assertEquals((1.23..4.56).hashCode(), (1.23..4.56).hashCode())
@@ -289,7 +289,7 @@ public class RangeTest {
assertEquals(("range".."progression").hashCode(), ("hashcode".."equals").hashCode())
}
@test fun comparableRange() {
@Test fun comparableRange() {
val range = "island".."isle"
assertFalse("apple" in range)
assertFalse("icicle" in range)
libraries/stdlib/test/reflection/AnnotationsTest.kt
+2 -2
View File
@@ -2,7 +2,7 @@
package test.reflection
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
@Retention(AnnotationRetention.RUNTIME)
annotation class MyAnno
@@ -13,7 +13,7 @@ class AnnotatedClass
class AnnotationTest {
@test fun annotationType() {
@Test fun annotationType() {
val kAnnotations = AnnotatedClass::class.java.annotations.map { it!!.annotationClass }
val jAnnotations = AnnotatedClass::class.java.annotations.map { it!!.annotationClass.java }
libraries/stdlib/test/text/CharJVMTest.kt
+2 -2
View File
@@ -2,11 +2,11 @@
package test.text
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class CharJVMTest {
@test fun getCategory() {
@Test fun getCategory() {
assertEquals(CharCategory.DECIMAL_DIGIT_NUMBER, '7'.category)
assertEquals(CharCategory.CURRENCY_SYMBOL, '$'.category)
assertEquals(CharCategory.LOWERCASE_LETTER, 'a'.category)
libraries/stdlib/test/text/RegexTest.kt
+14 -14
View File
@@ -3,11 +3,11 @@ package test.text
import kotlin.text.*
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class RegexTest {
@test fun matchResult() {
@Test fun matchResult() {
val p = "\\d+".toRegex()
val input = "123 456 789"
@@ -35,12 +35,12 @@ class RegexTest {
assertEquals(null, noMatch)
}
@test fun matchIgnoreCase() {
@Test fun matchIgnoreCase() {
for (input in listOf("ascii", "shrödinger"))
assertTrue(input.toUpperCase().matches(input.toLowerCase().toRegex(RegexOption.IGNORE_CASE)))
}
@test fun matchSequence() {
@Test fun matchSequence() {
val input = "123 456 789"
val pattern = "\\d+".toRegex()
@@ -54,7 +54,7 @@ class RegexTest {
assertEquals(listOf(0..2, 4..6, 8..10), matches.map { it.range }.toList())
}
@test fun matchAllSequence() {
@Test fun matchAllSequence() {
val input = "test"
val pattern = ".*".toRegex()
val matches = pattern.findAll(input).toList()
@@ -63,7 +63,7 @@ class RegexTest {
assertEquals(2, matches.size)
}
@test fun matchGroups() {
@Test fun matchGroups() {
val input = "1a 2b 3c"
val pattern = "(\\d)(\\w)".toRegex()
@@ -97,7 +97,7 @@ class RegexTest {
}
}
@test fun matchOptionalGroup() {
@Test fun matchOptionalGroup() {
val pattern = "(hi)|(bye)".toRegex(RegexOption.IGNORE_CASE)
pattern.find("Hi!")!!.let { m ->
@@ -127,14 +127,14 @@ class RegexTest {
}
}
@test fun matchMultiline() {
@Test fun matchMultiline() {
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)
}
@test fun matchEntire() {
@Test fun matchEntire() {
val regex = "(\\d)(\\w)".toRegex()
assertNull(regex.matchEntire("1a 2b"))
@@ -145,7 +145,7 @@ class RegexTest {
}
}
@test fun matchEntireLazyQuantor() {
@Test fun matchEntireLazyQuantor() {
val regex = "a+b+?".toRegex()
val input = StringBuilder("aaaabbbb")
@@ -153,13 +153,13 @@ class RegexTest {
assertEquals("aaaabbbb", regex.matchEntire(input)!!.value)
}
@test fun escapeLiteral() {
@Test fun escapeLiteral() {
val literal = """[-\/\\^$*+?.()|[\]{}]"""
assertTrue(Regex.fromLiteral(literal).matches(literal))
assertTrue(Regex.escape(literal).toRegex().matches(literal))
}
@test fun replace() {
@Test fun replace() {
val input = "123-456"
val pattern = "(\\d+)".toRegex()
assertEquals("(123)-(456)", pattern.replace(input, "($1)"))
@@ -168,14 +168,14 @@ class RegexTest {
assertEquals("X-456", pattern.replaceFirst(input, "X"))
}
@test fun replaceEvaluator() {
@Test fun replaceEvaluator() {
val input = "/12/456/7890/"
val pattern = "\\d+".toRegex()
assertEquals("/2/3/4/", pattern.replace(input, { it.value.length.toString() } ))
}
@test fun split() {
@Test fun split() {
val input = """
some ${"\t"} word
split
libraries/stdlib/test/text/StringBuilderJVMTest.kt
+3 -3
View File
@@ -2,17 +2,17 @@
package test.text
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class StringBuilderJVMTest() {
@test fun stringBuildWithInitialCapacity() {
@Test fun stringBuildWithInitialCapacity() {
val s = buildString(123) {
assertEquals(123, capacity())
}
}
@test fun getAndSetChar() {
@Test fun getAndSetChar() {
val sb = StringBuilder("abc")
sb[1] = 'z'
libraries/stdlib/test/text/StringBuilderTest.kt
+6 -6
View File
@@ -1,11 +1,11 @@
package test.text
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class StringBuilderTest {
@test fun stringBuild() {
@Test fun stringBuild() {
val s = buildString {
append("a")
append(true)
@@ -13,20 +13,20 @@ class StringBuilderTest {
assertEquals("atrue", s)
}
@test fun appendMany() {
@Test fun appendMany() {
assertEquals("a1", StringBuilder().append("a", "1").toString())
assertEquals("a1", StringBuilder().append("a", 1).toString())
assertEquals("a1", StringBuilder().append("a", StringBuilder().append("1")).toString())
}
@test fun append() {
@Test fun append() {
// this test is needed for JS implementation
assertEquals("em", buildString {
append("element", 2, 4)
})
}
@test fun asCharSequence() {
@Test fun asCharSequence() {
val original = "Some test string"
val sb = StringBuilder(original)
val result = sb.toString()
@@ -41,7 +41,7 @@ class StringBuilderTest {
assertEquals(result.substring(2, 6), cs.subSequence(2, 6).toString())
}
@test fun constructors() {
@Test fun constructors() {
StringBuilder().let { sb ->
assertEquals(0, sb.length)
assertEquals("", sb.toString())
libraries/stdlib/test/text/StringJVMTest.kt
+13 -13
View File
@@ -5,35 +5,35 @@ import test.collections.assertArrayNotSameButEquals
import java.util.Locale
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class StringJVMTest {
@test fun toBoolean() {
@Test fun toBoolean() {
assertEquals(true, "true".toBoolean())
assertEquals(true, "True".toBoolean())
assertEquals(false, "false".toBoolean())
assertEquals(false, "not so true".toBoolean())
}
@test fun toByte() {
@Test fun toByte() {
assertEquals(77.toByte(), "77".toByte())
assertFails { "255".toByte() }
}
@test fun toShort() {
@Test fun toShort() {
assertEquals(77.toShort(), "77".toShort())
}
@test fun toInt() {
@Test fun toInt() {
assertEquals(77, "77".toInt())
}
@test fun toLong() {
@Test fun toLong() {
assertEquals(77.toLong(), "77".toLong())
}
@test fun testSplitByPattern() = withOneCharSequenceArg("ab1cd2def3") { s ->
@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))
@@ -46,7 +46,7 @@ class StringJVMTest {
}
}
@test fun sliceCharSequenceFails() = withOneCharSequenceArg { arg1 ->
@Test fun sliceCharSequenceFails() = withOneCharSequenceArg { arg1 ->
assertFails {
arg1("abc").slice(1..4)
}
@@ -55,7 +55,7 @@ class StringJVMTest {
}
}
@test fun formatter() {
@Test fun formatter() {
assertEquals("12", "%d%d".format(1, 2))
assertEquals("12", String.format("%d%d", 1, 2))
@@ -67,12 +67,12 @@ class StringJVMTest {
assertEquals("1 234 567,890", String.format(Locale("fr"), "%,.3f", 1234567.890))
}
@test fun toByteArrayEncodings() {
@Test fun toByteArrayEncodings() {
val s = "hello®"
assertEquals(String(s.toByteArray()), String(s.toByteArray(Charsets.UTF_8)))
}
@test fun toCharArray() {
@Test fun toCharArray() {
val s = "hello"
val chars = s.toCharArray()
assertArrayNotSameButEquals(charArrayOf('h', 'e', 'l', 'l', 'o'), chars)
@@ -82,13 +82,13 @@ class StringJVMTest {
assertArrayNotSameButEquals(charArrayOf('\u0000', '\u0000', 'e', 'l'), buffer)
}
@test fun orderIgnoringCase() {
@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() {
@Test fun charsets() {
assertEquals("UTF-32", Charsets.UTF_32.name())
assertEquals("UTF-32LE", Charsets.UTF_32LE.name())
assertEquals("UTF-32BE", Charsets.UTF_32BE.name())
libraries/stdlib/test/text/StringTest.kt
+93 -93
View File
@@ -17,7 +17,7 @@
package test.text
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
fun createString(content: String): CharSequence = content
@@ -50,7 +50,7 @@ fun Char.isAsciiUpperCase() = this in 'A'..'Z'
class StringTest {
@test fun isEmptyAndBlank() = withOneCharSequenceArg { arg1 ->
@Test fun isEmptyAndBlank() = withOneCharSequenceArg { arg1 ->
class Case(val value: String?, val isNull: Boolean = false, val isEmpty: Boolean = false, val isBlank: Boolean = false)
val cases = listOf(
@@ -72,7 +72,7 @@ class StringTest {
}
}
@test fun orEmpty() {
@Test fun orEmpty() {
val s: String? = "hey"
val ns: String? = null
@@ -80,7 +80,7 @@ class StringTest {
assertEquals("", ns.orEmpty())
}
@test fun startsWithString() {
@Test fun startsWithString() {
assertTrue("abcd".startsWith("ab"))
assertTrue("abcd".startsWith("abcd"))
assertTrue("abcd".startsWith("a"))
@@ -94,7 +94,7 @@ class StringTest {
assertTrue("abcd".startsWith("aB", ignoreCase = true))
}
@test fun startsWithStringForCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
@Test fun startsWithStringForCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
fun String.startsWithCs(prefix: String, ignoreCase: Boolean = false): Boolean =
arg1(this).startsWith(arg2(prefix), ignoreCase)
@@ -111,7 +111,7 @@ class StringTest {
assertTrue("abcd".startsWithCs("aB", ignoreCase = true))
}
@test fun endsWithString() {
@Test fun endsWithString() {
assertTrue("abcd".endsWith("d"))
assertTrue("abcd".endsWith("abcd"))
assertFalse("abcd".endsWith("b"))
@@ -122,7 +122,7 @@ class StringTest {
assertTrue("".endsWith(""))
}
@test fun endsWithStringForCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
@Test fun endsWithStringForCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
fun String.endsWithCs(suffix: String, ignoreCase: Boolean = false): Boolean =
arg1(this).endsWith(arg2(suffix), ignoreCase)
@@ -136,7 +136,7 @@ class StringTest {
assertTrue("".endsWithCs(""))
}
@test fun startsWithChar() = withOneCharSequenceArg { arg1 ->
@Test fun startsWithChar() = withOneCharSequenceArg { arg1 ->
fun String.startsWith(char: Char, ignoreCase: Boolean = false): Boolean =
arg1(this).startsWith(char, ignoreCase)
@@ -147,7 +147,7 @@ class StringTest {
assertFalse("".startsWith('a'))
}
@test fun endsWithChar() = withOneCharSequenceArg { arg1 ->
@Test fun endsWithChar() = withOneCharSequenceArg { arg1 ->
fun String.endsWith(char: Char, ignoreCase: Boolean = false): Boolean =
arg1(this).endsWith(char, ignoreCase)
@@ -158,7 +158,7 @@ class StringTest {
assertFalse("".endsWith('a'))
}
@test fun commonPrefix() = withTwoCharSequenceArgs { arg1, arg2 ->
@Test fun commonPrefix() = withTwoCharSequenceArgs { arg1, arg2 ->
fun String.commonPrefixWith(other: String, ignoreCase: Boolean = false): String =
arg1(this).commonPrefixWith(arg2(other), ignoreCase)
@@ -177,7 +177,7 @@ class StringTest {
assertEquals(dth54, "$dth54$dth54".commonPrefixWith("$dth54$dth55"))
}
@test fun commonSuffix() = withTwoCharSequenceArgs { arg1, arg2 ->
@Test fun commonSuffix() = withTwoCharSequenceArgs { arg1, arg2 ->
fun String.commonSuffixWith(other: String, ignoreCase: Boolean = false): String =
arg1(this).commonSuffixWith(arg2(other), ignoreCase)
@@ -196,14 +196,14 @@ class StringTest {
assertEquals("$dth54", "d$dth54".commonSuffixWith("s$dth54"))
}
@test fun capitalize() {
@Test fun capitalize() {
assertEquals("A", "A".capitalize())
assertEquals("A", "a".capitalize())
assertEquals("Abcd", "abcd".capitalize())
assertEquals("Abcd", "Abcd".capitalize())
}
@test fun decapitalize() {
@Test fun decapitalize() {
assertEquals("a", "A".decapitalize())
assertEquals("a", "a".decapitalize())
assertEquals("abcd", "abcd".decapitalize())
@@ -211,7 +211,7 @@ class StringTest {
assertEquals("uRL", "URL".decapitalize())
}
@test fun slice() {
@Test fun slice() {
val iter = listOf(4, 3, 0, 1)
// abcde
// 01234
@@ -220,7 +220,7 @@ class StringTest {
assertEquals("edab", "abcde".slice(iter))
}
@test fun sliceCharSequence() = withOneCharSequenceArg { arg1 ->
@Test fun sliceCharSequence() = withOneCharSequenceArg { arg1 ->
val iter = listOf(4, 3, 0, 1)
val data = arg1("ABCDabcd")
@@ -231,13 +231,13 @@ class StringTest {
assertEquals("aDAB", data.slice(iter).toString())
}
@test fun reverse() {
@Test fun reverse() {
assertEquals("dcba", "abcd".reversed())
assertEquals("4321", "1234".reversed())
assertEquals("", "".reversed())
}
@test fun reverseCharSequence() = withOneCharSequenceArg { arg1 ->
@Test fun reverseCharSequence() = withOneCharSequenceArg { arg1 ->
fun String.reversedCs(): CharSequence = arg1(this).reversed()
assertContentEquals("dcba", "abcd".reversedCs())
@@ -245,7 +245,7 @@ class StringTest {
assertContentEquals("", "".reversedCs())
}
@test fun indices() = withOneCharSequenceArg { arg1 ->
@Test fun indices() = withOneCharSequenceArg { arg1 ->
fun String.indices(): IntRange = arg1(this).indices
assertEquals(0..4, "abcde".indices())
@@ -253,7 +253,7 @@ class StringTest {
assertTrue("".indices().isEmpty())
}
@test fun replaceRange() = withTwoCharSequenceArgs { arg1, arg2 ->
@Test fun replaceRange() = withTwoCharSequenceArgs { arg1, arg2 ->
val s = arg1("sample text")
val replacement = arg2("??")
@@ -270,7 +270,7 @@ class StringTest {
assertContentEquals(replacement.toString(), s.replaceRange(s.indices, replacement))
}
@test fun removeRange() = withOneCharSequenceArg("sample text") { s ->
@Test fun removeRange() = withOneCharSequenceArg("sample text") { s ->
assertContentEquals("sae text", s.removeRange(2, 5))
assertContentEquals("sa text", s.removeRange(2..5))
@@ -284,7 +284,7 @@ class StringTest {
assertContentEquals(s.toString().replaceRange(2..5, ""), s.removeRange(2..5))
}
@test fun substringDelimited() {
@Test fun substringDelimited() {
val s = "-1,22,3+"
// chars
assertEquals("22,3+", s.substringAfter(','))
@@ -308,7 +308,7 @@ class StringTest {
}
@test fun replaceDelimited() {
@Test fun replaceDelimited() {
val s = "/user/folder/file.extension"
// chars
assertEquals("/user/folder/file.doc", s.replaceAfter('.', "doc"))
@@ -331,7 +331,7 @@ class StringTest {
assertEquals("xxx", s.replaceBeforeLast("=", "/new/path", "xxx"))
}
@test fun repeat() = withOneCharSequenceArg { arg1 ->
@Test fun repeat() = withOneCharSequenceArg { arg1 ->
fun String.repeat(n: Int): String = arg1(this).repeat(n)
assertFails { "foo".repeat(-1) }
@@ -344,14 +344,14 @@ class StringTest {
assertEquals("aaaaaaaaaaaaa", "a".repeat(13))
}
@test fun stringIterator() = withOneCharSequenceArg("239") { data ->
@Test fun stringIterator() = withOneCharSequenceArg("239") { data ->
var sum = 0
for(c in data)
sum += (c - '0')
assertTrue(sum == 14)
}
@test fun trimStart() = withOneCharSequenceArg { arg1 ->
@Test fun trimStart() = withOneCharSequenceArg { arg1 ->
fun String.trimStartCS(): CharSequence = arg1(this).trimStart()
assertContentEquals("", "".trimStartCS())
assertContentEquals("a", "a".trimStartCS())
@@ -371,7 +371,7 @@ class StringTest {
assertContentEquals("123a", arg1("ab123a").trimStart { !it.isAsciiDigit() })
}
@test fun trimEnd() = withOneCharSequenceArg { arg1 ->
@Test fun trimEnd() = withOneCharSequenceArg { arg1 ->
fun String.trimEndCS(): CharSequence = arg1(this).trimEnd()
assertContentEquals("", "".trimEndCS())
assertContentEquals("a", "a".trimEndCS())
@@ -391,7 +391,7 @@ class StringTest {
assertContentEquals("ab123", arg1("ab123a").trimEnd { !it.isAsciiDigit() })
}
@test fun trimStartAndEnd() = withOneCharSequenceArg { arg1 ->
@Test fun trimStartAndEnd() = withOneCharSequenceArg { arg1 ->
val examples = arrayOf("a",
" a ",
" a ",
@@ -420,7 +420,7 @@ class StringTest {
}
}
@test fun padStart() = withOneCharSequenceArg { arg1 ->
@Test fun padStart() = withOneCharSequenceArg { arg1 ->
val s = arg1("s")
assertContentEquals("s", s.padStart(0))
assertContentEquals("s", s.padStart(1))
@@ -431,7 +431,7 @@ class StringTest {
}
}
@test fun padEnd() = withOneCharSequenceArg { arg1 ->
@Test fun padEnd() = withOneCharSequenceArg { arg1 ->
val s = arg1("s")
assertContentEquals("s", s.padEnd(0))
assertContentEquals("s", s.padEnd(1))
@@ -442,21 +442,21 @@ class StringTest {
}
}
@test fun removePrefix() = withOneCharSequenceArg("pre") { prefix ->
@Test fun removePrefix() = withOneCharSequenceArg("pre") { prefix ->
assertEquals("fix", "prefix".removePrefix(prefix), "Removes prefix")
assertEquals("prefix", "preprefix".removePrefix(prefix), "Removes prefix once")
assertEquals("sample", "sample".removePrefix(prefix))
assertEquals("sample", "sample".removePrefix(""))
}
@test fun removeSuffix() = withOneCharSequenceArg("fix") { suffix ->
@Test fun removeSuffix() = withOneCharSequenceArg("fix") { suffix ->
assertEquals("suf", "suffix".removeSuffix(suffix), "Removes suffix")
assertEquals("suffix", "suffixfix".removeSuffix(suffix), "Removes suffix once")
assertEquals("sample", "sample".removeSuffix(suffix))
assertEquals("sample", "sample".removeSuffix(""))
}
@test fun removeSurrounding() = withOneCharSequenceArg { arg1 ->
@Test fun removeSurrounding() = withOneCharSequenceArg { arg1 ->
val pre = arg1("<")
val post = arg1(">")
assertEquals("value", "<value>".removeSurrounding(pre, post))
@@ -468,7 +468,7 @@ class StringTest {
assertEquals("<->", "<->".removeSurrounding(arg1("<-"), arg1("->")), "Does not remove overlapping prefix and suffix")
}
@test fun removePrefixCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
@Test fun removePrefixCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
fun String.removePrefix(prefix: String) = arg1(this).removePrefix(arg2(prefix))
val prefix = "pre"
@@ -478,7 +478,7 @@ class StringTest {
assertContentEquals("sample", "sample".removePrefix(""))
}
@test fun removeSuffixCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
@Test fun removeSuffixCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
fun String.removeSuffix(suffix: String) = arg1(this).removeSuffix(arg2(suffix))
val suffix = "fix"
@@ -488,7 +488,7 @@ class StringTest {
assertContentEquals("sample", "sample".removeSuffix(""))
}
@test fun removeSurroundingCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
@Test fun removeSurroundingCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
fun String.removeSurrounding(prefix: String, postfix: String) = arg1(this).removeSurrounding(arg2(prefix), arg2(postfix))
assertContentEquals("value", "<value>".removeSurrounding("<", ">"))
@@ -517,7 +517,7 @@ class StringTest {
*/
@test fun split() = withOneCharSequenceArg { arg1 ->
@Test fun split() = withOneCharSequenceArg { arg1 ->
operator fun String.unaryPlus(): CharSequence = arg1(this)
assertEquals(listOf(""), (+"").split(";"))
@@ -534,7 +534,7 @@ class StringTest {
assertEquals(listOf("", "", "b", "b", "", ""), (+"abba").split("a", ""))
}
@test fun splitToLines() = withOneCharSequenceArg { arg1 ->
@Test fun splitToLines() = withOneCharSequenceArg { arg1 ->
val string = arg1("first line\rsecond line\nthird line\r\nlast line")
assertEquals(listOf("first line", "second line", "third line", "last line"), string.lines())
@@ -544,7 +544,7 @@ class StringTest {
}
@test fun indexOfAnyChar() = withOneCharSequenceArg("abracadabra") { string ->
@Test fun indexOfAnyChar() = withOneCharSequenceArg("abracadabra") { string ->
val chars = charArrayOf('d', 'b')
assertEquals(1, string.indexOfAny(chars))
assertEquals(6, string.indexOfAny(chars, startIndex = 2))
@@ -557,7 +557,7 @@ class StringTest {
assertEquals(-1, string.indexOfAny(charArrayOf()))
}
@test fun indexOfAnyCharIgnoreCase() = withOneCharSequenceArg("abraCadabra") { string ->
@Test fun indexOfAnyCharIgnoreCase() = withOneCharSequenceArg("abraCadabra") { string ->
val chars = charArrayOf('B', 'c')
assertEquals(1, string.indexOfAny(chars, ignoreCase = true))
assertEquals(4, string.indexOfAny(chars, startIndex = 2, ignoreCase = true))
@@ -568,7 +568,7 @@ class StringTest {
assertEquals(-1, string.lastIndexOfAny(chars, startIndex = 0, ignoreCase = true))
}
@test fun indexOfAnyString() = withOneCharSequenceArg("abracadabra") { string ->
@Test fun indexOfAnyString() = withOneCharSequenceArg("abracadabra") { string ->
val substrings = listOf("rac", "ra")
assertEquals(2, string.indexOfAny(substrings))
assertEquals(9, string.indexOfAny(substrings, startIndex = 3))
@@ -584,7 +584,7 @@ class StringTest {
assertEquals(-1, string.indexOfAny(listOf()))
}
@test fun indexOfAnyStringIgnoreCase() = withOneCharSequenceArg("aBraCadaBrA") { string ->
@Test fun indexOfAnyStringIgnoreCase() = withOneCharSequenceArg("aBraCadaBrA") { string ->
val substrings = listOf("rAc", "Ra")
assertEquals(2, string.indexOfAny(substrings, ignoreCase = true))
@@ -596,7 +596,7 @@ class StringTest {
assertEquals(-1, string.lastIndexOfAny(substrings, startIndex = 1, ignoreCase = true))
}
@test fun findAnyOfStrings() = withOneCharSequenceArg("abracadabra") { string ->
@Test fun findAnyOfStrings() = withOneCharSequenceArg("abracadabra") { string ->
val substrings = listOf("rac", "ra")
assertEquals(2 to "rac", string.findAnyOf(substrings))
assertEquals(9 to "ra", string.findAnyOf(substrings, startIndex = 3))
@@ -612,7 +612,7 @@ class StringTest {
assertEquals(null, string.findAnyOf(listOf()))
}
@test fun findAnyOfStringsIgnoreCase() = withOneCharSequenceArg("aBraCadaBrA") { string ->
@Test fun findAnyOfStringsIgnoreCase() = withOneCharSequenceArg("aBraCadaBrA") { string ->
val substrings = listOf("rAc", "Ra")
assertEquals(2 to substrings[0], string.findAnyOf(substrings, ignoreCase = true))
@@ -624,7 +624,7 @@ class StringTest {
assertEquals(null, string.findLastAnyOf(substrings, startIndex = 1, ignoreCase = true))
}
@test fun indexOfChar() = withOneCharSequenceArg("bcedef") { string ->
@Test fun indexOfChar() = withOneCharSequenceArg("bcedef") { string ->
assertEquals(-1, string.indexOf('a'))
assertEquals(2, string.indexOf('e'))
assertEquals(2, string.indexOf('e', 2))
@@ -639,7 +639,7 @@ class StringTest {
}
@test fun indexOfCharIgnoreCase() = withOneCharSequenceArg("bCEdef") { string ->
@Test fun indexOfCharIgnoreCase() = withOneCharSequenceArg("bCEdef") { string ->
assertEquals(-1, string.indexOf('a', ignoreCase = true))
assertEquals(2, string.indexOf('E', ignoreCase = true))
assertEquals(2, string.indexOf('e', 2, ignoreCase = true))
@@ -654,7 +654,7 @@ class StringTest {
}
}
@test fun indexOfString() = withOneCharSequenceArg("bceded") { string ->
@Test fun indexOfString() = withOneCharSequenceArg("bceded") { string ->
for (index in string.indices)
assertEquals(index, string.indexOf("", index))
assertEquals(1, string.indexOf("ced"))
@@ -662,7 +662,7 @@ class StringTest {
assertEquals(-1, string.indexOf("abcdefgh"))
}
@test fun indexOfStringIgnoreCase() = withOneCharSequenceArg("bceded") { string ->
@Test fun indexOfStringIgnoreCase() = withOneCharSequenceArg("bceded") { string ->
for (index in string.indices)
assertEquals(index, string.indexOf("", index, ignoreCase = true))
assertEquals(1, string.indexOf("cEd", ignoreCase = true))
@@ -671,7 +671,7 @@ class StringTest {
}
@test fun contains() = withTwoCharSequenceArgs { arg1, arg2 ->
@Test fun contains() = withTwoCharSequenceArgs { arg1, arg2 ->
operator fun String.contains(other: String): Boolean = arg1(this).contains(arg2(other))
operator fun String.contains(other: Char): Boolean = arg1(this).contains(other)
@@ -687,7 +687,7 @@ class StringTest {
assertTrue(arg1("sömple").contains('Ö', ignoreCase = true))
}
@test fun equalsIgnoreCase() {
@Test fun equalsIgnoreCase() {
assertFalse("sample".equals("Sample", ignoreCase = false))
assertTrue("sample".equals("Sample", ignoreCase = true))
assertFalse("sample".equals(null, ignoreCase = false))
@@ -697,7 +697,7 @@ class StringTest {
}
@test fun replace() {
@Test fun replace() {
val input = "abbAb"
assertEquals("abb${'$'}b", input.replace('A', '$'))
assertEquals("/bb/b", input.replace('A', '/', ignoreCase = true))
@@ -708,7 +708,7 @@ class StringTest {
assertEquals("-a-b-b-A-b-", input.replace("", "-"))
}
@test fun replaceFirst() {
@Test fun replaceFirst() {
val input = "AbbabA"
assertEquals("Abb${'$'}bA", input.replaceFirst('a','$'))
assertEquals("${'$'}bbabA", input.replaceFirst('a','$', ignoreCase = true))
@@ -721,12 +721,12 @@ class StringTest {
assertEquals("-test", "test".replaceFirst("", "-"))
}
@test fun count() = withOneCharSequenceArg("hello there\tfoo\nbar") { text ->
@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 ->
@Test fun testSplitByChar() = withOneCharSequenceArg("ab\n[|^$&\\]^cd") { s ->
s.split('b').let { list ->
assertEquals(2, list.size)
assertEquals("a", list[0])
@@ -742,7 +742,7 @@ class StringTest {
}
}
@test fun forEach() = withOneCharSequenceArg("abcd1234") { data ->
@Test fun forEach() = withOneCharSequenceArg("abcd1234") { data ->
var count = 0
val sb = StringBuilder()
data.forEach {
@@ -754,36 +754,36 @@ class StringTest {
}
@test fun filter() {
@Test fun filter() {
assertEquals("acdca", ("abcdcba").filter { !it.equals('b') })
assertEquals("1234", ("a1b2c3d4").filter { it.isAsciiDigit() })
}
@test fun filterCharSequence() = withOneCharSequenceArg { arg1 ->
@Test fun filterCharSequence() = withOneCharSequenceArg { arg1 ->
assertContentEquals("acdca", arg1("abcdcba").filter { !it.equals('b') })
assertContentEquals("1234", arg1("a1b2c3d4").filter { it.isAsciiDigit() })
}
@test fun filterNot() {
@Test fun filterNot() {
assertEquals("acdca", ("abcdcba").filterNot { it.equals('b') })
assertEquals("abcd", ("a1b2c3d4").filterNot { it.isAsciiDigit() })
}
@test fun filterNotCharSequence() = withOneCharSequenceArg { arg1 ->
@Test fun filterNotCharSequence() = withOneCharSequenceArg { arg1 ->
assertContentEquals("acdca", arg1("abcdcba").filterNot { it.equals('b') })
assertContentEquals("abcd", arg1("a1b2c3d4").filterNot { it.isAsciiDigit() })
}
@test fun filterIndexed() {
@Test fun filterIndexed() {
val data = "abedcf"
assertEquals("abdf", data.filterIndexed { index, c -> c == 'a' + index })
}
@test fun filterIndexedCharSequence() = withOneCharSequenceArg("abedcf") { data ->
@Test fun filterIndexedCharSequence() = withOneCharSequenceArg("abedcf") { data ->
assertContentEquals("abdf", data.filterIndexed { index, c -> c == 'a' + index })
}
@test fun all() = withOneCharSequenceArg("AbCd") { data ->
@Test fun all() = withOneCharSequenceArg("AbCd") { data ->
assertTrue {
data.all { it.isAsciiLetter() }
}
@@ -792,7 +792,7 @@ class StringTest {
}
}
@test fun any() = withOneCharSequenceArg("a1bc") { data ->
@Test fun any() = withOneCharSequenceArg("a1bc") { data ->
assertTrue {
data.any() { it.isAsciiDigit() }
}
@@ -801,30 +801,30 @@ class StringTest {
}
}
@test fun find() = withOneCharSequenceArg("a1b2c3") { data ->
@Test fun find() = withOneCharSequenceArg("a1b2c3") { data ->
assertEquals('1', data.first { it.isAsciiDigit() })
assertNull(data.firstOrNull { it.isAsciiUpperCase() })
}
@test fun findNot() = withOneCharSequenceArg("1a2b3c") { data ->
@Test fun findNot() = withOneCharSequenceArg("1a2b3c") { data ->
assertEquals('a', data.filterNot { it.isAsciiDigit() }.firstOrNull())
assertNull(data.filterNot { it.isAsciiLetter() || it.isAsciiDigit() }.firstOrNull())
}
@test fun partition() {
@Test fun partition() {
val data = "a1b2c3"
val pair = data.partition { it.isAsciiDigit() }
assertEquals("123", pair.first, "pair.first")
assertEquals("abc", pair.second, "pair.second")
}
@test fun partitionCharSequence() = withOneCharSequenceArg("a1b2c3") { data ->
@Test fun partitionCharSequence() = withOneCharSequenceArg("a1b2c3") { data ->
val pair = data.partition { it.isAsciiDigit() }
assertContentEquals("123", pair.first, "pair.first")
assertContentEquals("abc", pair.second, "pair.second")
}
@test fun map() = withOneCharSequenceArg { arg1 ->
@Test fun map() = withOneCharSequenceArg { arg1 ->
assertEquals(listOf('a', 'b', 'c'), arg1("abc").map { it })
assertEquals(listOf(true, false, true), arg1("AbC").map { it.isAsciiUpperCase() })
@@ -834,7 +834,7 @@ class StringTest {
assertEquals(listOf(97, 98, 99), arg1("abc").map { it.toInt() })
}
@test fun mapTo() = withOneCharSequenceArg { arg1 ->
@Test fun mapTo() = withOneCharSequenceArg { arg1 ->
val result1 = arrayListOf<Char>()
val return1 = arg1("abc").mapTo(result1, { it })
assertEquals(result1, return1)
@@ -856,12 +856,12 @@ class StringTest {
assertEquals(arrayListOf(97, 98, 99), result4)
}
@test fun flatMap() = withOneCharSequenceArg("abcd") { data ->
@Test fun flatMap() = withOneCharSequenceArg("abcd") { data ->
val result = data.flatMap { ('a'..it) + ' ' }
assertEquals("a ab abc abcd ".toList(), result)
}
@test fun fold() = withOneCharSequenceArg { arg1 ->
@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 } )
@@ -874,7 +874,7 @@ class StringTest {
assertEquals(data.toString(), data.fold("", { s, c -> s + c }))
}
@test fun foldRight() = withOneCharSequenceArg { arg1 ->
@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 })
@@ -887,7 +887,7 @@ class StringTest {
assertEquals(data.toString(), data.foldRight("", { s, c -> "" + s + c }))
}
@test fun reduceIndexed() = withOneCharSequenceArg { arg1 ->
@Test fun reduceIndexed() = withOneCharSequenceArg { arg1 ->
// get the 3rd character
assertEquals('c', arg1("bacfd").reduceIndexed { index, v, c -> if (index == 2) c else v })
@@ -905,7 +905,7 @@ class StringTest {
}
}
@test fun reduceRightIndexed() = withOneCharSequenceArg { arg1 ->
@Test fun reduceRightIndexed() = withOneCharSequenceArg { arg1 ->
// get the 3rd character
assertEquals('c', arg1("bacfd").reduceRightIndexed { index, c, v -> if (index == 2) c else v })
@@ -923,7 +923,7 @@ class StringTest {
}
}
@test fun reduce() = withOneCharSequenceArg { arg1 ->
@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 })
@@ -932,7 +932,7 @@ class StringTest {
}
}
@test fun reduceRight() = withOneCharSequenceArg { arg1 ->
@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 })
@@ -941,7 +941,7 @@ class StringTest {
}
}
@test fun groupBy() = withOneCharSequenceArg("abAbaABcD") { data ->
@Test fun groupBy() = withOneCharSequenceArg("abAbaABcD") { data ->
// group characters by their case
val result = data.groupBy { it.isAsciiUpperCase() }
assertEquals(2, result.size)
@@ -949,7 +949,7 @@ class StringTest {
assertEquals(listOf('A','A','B','D'), result[true])
}
@test fun joinToString() {
@Test fun joinToString() {
val data = "abcd".toList()
val result = data.joinToString("_", "(", ")")
assertEquals("(a_b_c_d)", result)
@@ -963,7 +963,7 @@ class StringTest {
assertEquals("A, 1, /, B", result3)
}
@test fun joinTo() {
@Test fun joinTo() {
val data = "kotlin".toList()
val sb = StringBuilder()
data.joinTo(sb, "^", "<", ">")
@@ -971,21 +971,21 @@ class StringTest {
}
@test fun dropWhile() {
@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 ->
@Test fun dropWhileCharSequence() = withOneCharSequenceArg("ab1cd2") { data ->
assertContentEquals("1cd2", data.dropWhile { it.isAsciiLetter() })
assertContentEquals("", data.dropWhile { true })
assertContentEquals("ab1cd2", data.dropWhile { false })
}
@test fun drop() {
@Test fun drop() {
val data = "abcd1234"
assertEquals("d1234", data.drop(3))
assertFails {
@@ -994,7 +994,7 @@ class StringTest {
assertEquals("", data.drop(data.length + 5))
}
@test fun dropCharSequence() = withOneCharSequenceArg("abcd1234") { data ->
@Test fun dropCharSequence() = withOneCharSequenceArg("abcd1234") { data ->
assertContentEquals("d1234", data.drop(3))
assertFails {
data.drop(-2)
@@ -1002,20 +1002,20 @@ class StringTest {
assertContentEquals("", data.drop(data.length + 5))
}
@test fun takeWhile() {
@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 ->
@Test fun takeWhileCharSequence() = withOneCharSequenceArg("ab1cd2") { data ->
assertContentEquals("ab", data.takeWhile { it.isAsciiLetter() })
assertContentEquals("", data.takeWhile { false })
assertContentEquals("ab1cd2", data.takeWhile { true })
}
@test fun take() {
@Test fun take() {
val data = "abcd1234"
assertEquals("abc", data.take(3))
assertFails {
@@ -1024,7 +1024,7 @@ class StringTest {
assertEquals(data, data.take(data.length + 42))
}
@test fun takeCharSequence() = withOneCharSequenceArg("abcd1234") { data ->
@Test fun takeCharSequence() = withOneCharSequenceArg("abcd1234") { data ->
assertEquals("abc", data.take(3))
assertFails {
data.take(-7)
@@ -1033,28 +1033,28 @@ class StringTest {
}
@test fun testReplaceAllClosure() = withOneCharSequenceArg("test123zzz") { s ->
@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 ->
@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 ->
@Test fun testReplaceAllClosureAtEnd() = withOneCharSequenceArg("test123") { s ->
val result = s.replace("\\d+".toRegex()) { mr ->
"[" + mr.value + "]"
}
assertEquals("test[123]", result)
}
@test fun testReplaceAllClosureEmpty() = withOneCharSequenceArg("") { s ->
@Test fun testReplaceAllClosureEmpty() = withOneCharSequenceArg("") { s ->
val result = s.replace("\\d+".toRegex()) { mr ->
"x"
}
@@ -1062,7 +1062,7 @@ class StringTest {
}
@test fun trimMargin() {
@Test fun trimMargin() {
// WARNING
// DO NOT REFORMAT AS TESTS MAY FAIL DUE TO INDENTATION CHANGE
@@ -1109,7 +1109,7 @@ class StringTest {
assertEquals("\u0000|ABC", "${"\u0000"}|ABC".trimMargin())
}
@test fun trimIndent() {
@Test fun trimIndent() {
// WARNING
// DO NOT REFORMAT AS TESTS MAY FAIL DUE TO INDENTATION CHANGE
@@ -1173,7 +1173,7 @@ ${" "}
assertEquals(1, deindented.lines().count { it.isEmpty() })
}
@test fun testIndent() {
@Test fun testIndent() {
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(" "))
libraries/stdlib/test/utils/LazyJVMTest.kt
+5 -5
View File
@@ -8,11 +8,11 @@ import java.io.*
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.atomic.AtomicInteger
import kotlin.concurrent.thread
import org.junit.Test as test
import org.junit.Test
class LazyJVMTest {
@test fun synchronizedLazy() {
@Test fun synchronizedLazy() {
val counter = AtomicInteger(0)
val lazy = lazy {
val value = counter.incrementAndGet()
@@ -26,7 +26,7 @@ class LazyJVMTest {
assertEquals(1, counter.get())
}
@test fun externallySynchronizedLazy() {
@Test fun externallySynchronizedLazy() {
val counter = AtomicInteger(0)
var initialized: Boolean = false
val runs = ConcurrentHashMap<Int, Boolean>()
@@ -51,7 +51,7 @@ class LazyJVMTest {
}
}
@test fun publishOnceLazy() {
@Test fun publishOnceLazy() {
val counter = AtomicInteger(0)
var initialized: Boolean = false
val runs = ConcurrentHashMap<Int, Boolean>()
@@ -75,7 +75,7 @@ class LazyJVMTest {
}
}
@test fun lazyInitializationForcedOnSerialization() {
@Test fun lazyInitializationForcedOnSerialization() {
for(mode in listOf(LazyThreadSafetyMode.SYNCHRONIZED, LazyThreadSafetyMode.PUBLICATION, LazyThreadSafetyMode.NONE)) {
val lazy = lazy(mode) { "initialized" }
assertFalse(lazy.isInitialized())
libraries/stdlib/test/utils/LazyTest.kt
+4 -4
View File
@@ -2,11 +2,11 @@ package test.utils
import kotlin.*
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class LazyTest {
@test fun initializationCalledOnce() {
@Test fun initializationCalledOnce() {
var callCount = 0
val lazyInt = lazy { ++callCount }
@@ -20,7 +20,7 @@ class LazyTest {
assertEquals(1, callCount)
}
@test fun alreadyInitialized() {
@Test fun alreadyInitialized() {
val lazyInt = lazyOf(1)
assertTrue(lazyInt.isInitialized())
@@ -28,7 +28,7 @@ class LazyTest {
}
@test fun lazyToString() {
@Test fun lazyToString() {
var callCount = 0
val lazyInt = lazy { ++callCount }
libraries/stdlib/test/utils/PreconditionsJVMTest.kt
+18 -18
View File
@@ -1,12 +1,12 @@
@file:kotlin.jvm.JvmVersion
package test.utils
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
class PreconditionsJVMTest() {
@test fun passingRequire() {
@Test fun passingRequire() {
require(true)
var called = false
@@ -14,21 +14,21 @@ class PreconditionsJVMTest() {
assertFalse(called)
}
@test fun failingRequire() {
@Test fun failingRequire() {
val error = assertFailsWith(IllegalArgumentException::class) {
require(false)
}
assertNotNull(error.message)
}
@test fun failingRequireWithLazyMessage() {
@Test fun failingRequireWithLazyMessage() {
val error = assertFailsWith(IllegalArgumentException::class) {
require(false) { "Hello" }
}
assertEquals("Hello", error.message)
}
@test fun passingCheck() {
@Test fun passingCheck() {
check(true)
var called = false
@@ -36,34 +36,34 @@ class PreconditionsJVMTest() {
assertFalse(called)
}
@test fun failingCheck() {
@Test fun failingCheck() {
val error = assertFailsWith(IllegalStateException::class) {
check(false)
}
assertNotNull(error.message)
}
@test fun failingCheckWithLazyMessage() {
@Test fun failingCheckWithLazyMessage() {
val error = assertFailsWith(IllegalStateException::class) {
check(false) { "Hello" }
}
assertEquals("Hello", error.message)
}
@test fun requireNotNull() {
@Test fun requireNotNull() {
val s1: String? = "S1"
val r1: String = requireNotNull(s1)
assertEquals("S1", r1)
}
@test fun requireNotNullFails() {
@Test fun requireNotNullFails() {
assertFailsWith(IllegalArgumentException::class) {
val s2: String? = null
requireNotNull(s2)
}
}
@test fun requireNotNullWithLazyMessage() {
@Test fun requireNotNullWithLazyMessage() {
val error = assertFailsWith(IllegalArgumentException::class) {
val obj: Any? = null
requireNotNull(obj) { "Message" }
@@ -78,20 +78,20 @@ class PreconditionsJVMTest() {
assertFalse(lazyCalled, "Message is not evaluated if the condition is met")
}
@test fun checkNotNull() {
@Test fun checkNotNull() {
val s1: String? = "S1"
val r1: String = checkNotNull(s1)
assertEquals("S1", r1)
}
@test fun checkNotNullFails() {
@Test fun checkNotNullFails() {
assertFailsWith(IllegalStateException::class) {
val s2: String? = null
checkNotNull(s2)
}
}
@test fun passingAssert() {
@Test fun passingAssert() {
assert(true)
var called = false
assert(true) { called = true; "some message" }
@@ -100,7 +100,7 @@ class PreconditionsJVMTest() {
}
@test fun failingAssert() {
@Test fun failingAssert() {
val error = assertFails {
assert(false)
}
@@ -111,7 +111,7 @@ class PreconditionsJVMTest() {
}
}
@test fun error() {
@Test fun error() {
val error = assertFails {
error("There was a problem")
}
@@ -122,11 +122,11 @@ class PreconditionsJVMTest() {
}
}
@test fun passingAssertWithMessage() {
@Test fun passingAssertWithMessage() {
assert(true) { "Hello" }
}
@test fun failingAssertWithMessage() {
@Test fun failingAssertWithMessage() {
val error = assertFails {
assert(false) { "Hello" }
}
@@ -137,7 +137,7 @@ class PreconditionsJVMTest() {
}
}
@test fun failingAssertWithLazyMessage() {
@Test fun failingAssertWithLazyMessage() {
val error = assertFails {
assert(false) { "Hello" }
}
libraries/stdlib/test/utils/TODOTest.kt
+2 -2
View File
@@ -18,7 +18,7 @@ package test.utils
import kotlin.*
import kotlin.test.*
import org.junit.Test as test
import org.junit.Test
class TODOTest {
private class PartiallyImplementedClass {
@@ -52,7 +52,7 @@ class TODOTest {
}
@test fun usage() {
@Test fun usage() {
val inst = PartiallyImplementedClass()
assertNotImplemented { inst.prop }