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

Reformat stdlib tests and samples

Browse Source 
#KT-5558
This commit is contained in:
Ilya Gorbunov
2018-04-23 16:18:24 +03:00
parent add09e0f2e
commit ecf0d7ec0d
39 changed files with 389 additions and 284 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/stdlib/js/test/core/PromiseTest.kt
+23 -23
View File
@@ -24,33 +24,33 @@ class PromiseTest {
assertStaticTypeIs<Promise<Int>>(p.then(f, ft))
assertStaticTypeIs<Promise<Int>>(
p.then({
1
} , {
1
})
p.then({
1
}, {
1
})
)
assertStaticTypeIs<Promise<Int>>(
p.then({
1
}) {
1
}
p.then({
1
}) {
1
}
)
assertStaticTypeIs<Promise<Int>>(
p.then(onFulfilled = {
1
})
p.then(onFulfilled = {
1
})
)
assertStaticTypeIs<Promise<Int>>(
p.then(onFulfilled = {
1
}) {
1
}
p.then(onFulfilled = {
1
}) {
1
}
)
p.then {
@@ -59,12 +59,12 @@ class PromiseTest {
assertStaticAndRuntimeTypeIs<String>(it)
ps
}.then(
{
assertStaticAndRuntimeTypeIs<String>(it)
},
{
{
assertStaticAndRuntimeTypeIs<String>(it)
},
{
}
}
)
}
}
libraries/stdlib/jvm/test/collections/CollectionJVMTest.kt
+6 -6
View File
@@ -192,16 +192,16 @@ class CollectionJVMTest {
}
@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>())
"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(
"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>())
"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(
"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>())
"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>())
private fun testPersistedDeserialization(hexValue: String, expected: Any) {
val actual = deserializeFromHex<Any>(hexValue)
libraries/stdlib/jvm/test/collections/IterableJVMTests.kt
+1 -1
View File
@@ -7,5 +7,5 @@ package test.collections
import java.util.*
class LinkedListTest : OrderedIterableTests<LinkedList<String>>( { LinkedList(it.asList()) }, LinkedList<String>())
class LinkedListTest : OrderedIterableTests<LinkedList<String>>({ LinkedList(it.asList()) }, LinkedList<String>())
libraries/stdlib/jvm/test/concurrent/ThreadTest.kt
+1 -1
View File
@@ -46,7 +46,7 @@ class ThreadTest {
assertEquals("v3", v.getOrSet { "v2" })
val w = object: ThreadLocal<String>() {
val w = object : ThreadLocal<String>() {
override fun initialValue() = "default"
}
libraries/stdlib/jvm/test/io/Console.kt
+1
View File
@@ -4,6 +4,7 @@
*/
@file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
package test.io
import org.junit.Test
libraries/stdlib/jvm/test/io/Files.kt
+2 -4
View File
@@ -521,8 +521,7 @@ class FilesTest {
}
var conflicts = 0
src.copyRecursively(dst) {
_: File, e: IOException ->
src.copyRecursively(dst) { _: File, e: IOException ->
if (e is FileAlreadyExistsException) {
conflicts++
OnErrorAction.SKIP
@@ -536,8 +535,7 @@ class FilesTest {
try {
dst.deleteRecursively()
var caught = false
assertTrue(src.copyRecursively(dst) {
_: File, e: IOException ->
assertTrue(src.copyRecursively(dst) { _: File, e: IOException ->
if (e is AccessDeniedException) {
caught = true
OnErrorAction.SKIP
libraries/stdlib/jvm/test/io/IOStreams.kt
+1 -1
View File
@@ -36,7 +36,7 @@ class IOStreamsTest {
val result = mutableListOf<Byte>()
x.inputStream().buffered().use { stream ->
for(b in stream) {
for (b in stream) {
result += b
}
}
libraries/stdlib/jvm/test/io/SerializableTest.kt
+1 -1
View File
@@ -87,5 +87,5 @@ private fun hexToBytes(value: String): ByteArray = value.split(" ").map { Intege
public fun <T> deserializeFromHex(value: String) = deserializeFromByteArray<T>(hexToBytes(value))
public fun <T> serializeToHex(value: T) =
serializeToByteArray(value).joinToString(" ") { (it.toInt() and 0xFF).toString(16).padStart(2, '0') }
serializeToByteArray(value).joinToString(" ") { (it.toInt() and 0xFF).toString(16).padStart(2, '0') }
libraries/stdlib/jvm/test/numbers/BigNumbersTest.kt
+3 -4
View File
@@ -39,7 +39,7 @@ class BigNumbersTest {
assertEquals(BigInteger("-1"), -a shr 1)
assertEquals(BigInteger("-1"), -a shr 2)
assertEquals(BigInteger("2"), 2.toBigInteger())
assertEquals(BigInteger("2"), 2.toBigInteger())
assertEquals(BigInteger("-3"), -3L.toBigInteger())
assertEquals(BigDecimal("2"), a.toBigDecimal())
@@ -50,7 +50,6 @@ class BigNumbersTest {
assertEquals(BigDecimal("3"), BigInteger("253").toBigDecimal(2, MathContext(1, RoundingMode.UP)))
var c = 2.toBigInteger()
assertEquals(BigInteger("2"), c++)
assertEquals(BigInteger("3"), c)
@@ -79,10 +78,10 @@ class BigNumbersTest {
assertEquals(BigDecimal("3"), a.inc())
assertEquals(BigDecimal("1"), a.dec())
assertEquals(BigDecimal("2"), 2.toBigDecimal())
assertEquals(BigDecimal("2"), 2.toBigDecimal())
assertEquals(BigDecimal("-3"), -3L.toBigDecimal())
assertEquals(BigDecimal("2.0"), 2f.toBigDecimal())
assertEquals(BigDecimal("0.5"), 0.5.toBigDecimal())
assertEquals(BigDecimal("0.5"), 0.5.toBigDecimal())
var c = "1.5".toBigDecimal()
assertEquals(BigDecimal("1.5"), c++)
libraries/stdlib/jvm/test/utils/LazyJVMTest.kt
+17 -12
View File
@@ -87,7 +87,7 @@ class LazyJVMTest {
List(threads) { lazy(lock, initializer) }
},
access = { lazies, runnerIndex -> lazies[runnerIndex].value },
validate = { result -> result.all { (id, initialized) -> initialized == (id != 1)} })
validate = { result -> result.all { (id, initialized) -> initialized == (id != 1) } })
}
@Test fun publishOnceLazy() {
@@ -95,7 +95,9 @@ class LazyJVMTest {
val initialized = AtomicBoolean(false)
val threads = 3
val values = Random().let { r -> List(threads) { 50 + r.nextInt(50) } }
data class Run(val value: Int, val initialized: Boolean)
val runs = ConcurrentLinkedQueue<Run>()
val initializer = {
@@ -124,11 +126,11 @@ class LazyJVMTest {
@Test fun publishOnceLazyRace() {
racyTest(initialize = { lazy(LazyThreadSafetyMode.PUBLICATION) { Thread.currentThread().id } },
access = { lazy, _ -> lazy.value },
validate = { result -> result.all { v -> v == result[0] } } )
validate = { result -> result.all { v -> v == result[0] } })
}
@Test fun lazyInitializationForcedOnSerialization() {
for(mode in listOf(LazyThreadSafetyMode.SYNCHRONIZED, LazyThreadSafetyMode.PUBLICATION, LazyThreadSafetyMode.NONE)) {
for (mode in listOf(LazyThreadSafetyMode.SYNCHRONIZED, LazyThreadSafetyMode.PUBLICATION, LazyThreadSafetyMode.NONE)) {
val lazy = lazy(mode) { "initialized" }
assertFalse(lazy.isInitialized())
val lazy2 = serializeAndDeserialize(lazy)
@@ -139,10 +141,11 @@ class LazyJVMTest {
}
private fun <TState : Any, TResult> racyTest(
threads: Int = 3, runs: Int = 5000,
initialize: () -> TState,
access: (TState, runnerIndex: Int) -> TResult,
validate: (List<TResult>) -> Boolean) {
threads: Int = 3, runs: Int = 5000,
initialize: () -> TState,
access: (TState, runnerIndex: Int) -> TResult,
validate: (List<TResult>) -> Boolean
) {
val runResult = java.util.Collections.synchronizedList(mutableListOf<TResult>())
val invalidResults = mutableListOf<Pair<Int, List<TResult>>>()
@@ -159,13 +162,15 @@ class LazyJVMTest {
runId += 1
}
val runners = List(threads) { index -> thread {
barrier.await()
repeat(runs) {
runResult += access(state, index)
val runners = List(threads) { index ->
thread {
barrier.await()
repeat(runs) {
runResult += access(state, index)
barrier.await()
}
}
}}
}
runners.forEach { it.join() }
libraries/stdlib/samples/test/samples/collections/arrays.kt
+6 -6
View File
@@ -40,9 +40,9 @@ class Arrays {
@Sample
fun flattenArray() {
val deepArray = arrayOf(
arrayOf(1),
arrayOf(2, 3),
arrayOf(4, 5, 6)
arrayOf(1),
arrayOf(2, 3),
arrayOf(4, 5, 6)
)
assertPrints(deepArray.flatten(), "[1, 2, 3, 4, 5, 6]")
@@ -67,9 +67,9 @@ class Arrays {
@Sample
fun contentDeepToString() {
val matrix = arrayOf(
intArrayOf(3, 7, 9),
intArrayOf(0, 1, 0),
intArrayOf(2, 4, 8)
intArrayOf(3, 7, 9),
intArrayOf(0, 1, 0),
intArrayOf(2, 4, 8)
)
assertPrints(matrix.contentDeepToString(), "[[3, 7, 9], [0, 1, 0], [2, 4, 8]]")
libraries/stdlib/samples/test/samples/collections/sequences.kt
+3 -3
View File
@@ -40,8 +40,8 @@ class Sequences {
class LinkedValue<T>(val value: T, val next: LinkedValue<T>? = null)
fun <T> LinkedValue<T>?.asSequence(): Sequence<LinkedValue<T>> = generateSequence(
seedFunction = { this },
nextFunction = { it.next }
seedFunction = { this },
nextFunction = { it.next }
)
fun <T> LinkedValue<T>?.valueSequence(): Sequence<T> = asSequence().map { it.value }
@@ -116,7 +116,7 @@ class Sequences {
var terms = Pair(0, 1)
// this sequence is infinite
while(true) {
while (true) {
yield(terms.first)
terms = Pair(terms.second, terms.first + terms.second)
}
libraries/stdlib/samples/test/samples/comparisons/comparisons.kt
+13 -13
View File
@@ -23,7 +23,7 @@ class Comparisons {
@Sample
fun compareValuesByWithSingleSelector() {
fun compareLength(a: String, b: String): Int =
compareValuesBy(a, b) { it.length }
compareValuesBy(a, b) { it.length }
assertTrue(compareLength("a", "b") == 0)
assertTrue(compareLength("bb", "a") > 0)
@@ -33,7 +33,7 @@ class Comparisons {
@Sample
fun compareValuesByWithSelectors() {
fun compareLengthThenString(a: String, b: String): Int =
compareValuesBy(a, b, { it.length }, { it })
compareValuesBy(a, b, { it.length }, { it })
assertTrue(compareLengthThenString("b", "aa") < 0)
@@ -45,7 +45,7 @@ class Comparisons {
@Sample
fun compareValuesByWithComparator() {
fun compareInsensitiveOrder(a: Char, b: Char): Int =
compareValuesBy(a, b, String.CASE_INSENSITIVE_ORDER, { c -> c.toString() })
compareValuesBy(a, b, String.CASE_INSENSITIVE_ORDER, { c -> c.toString() })
assertTrue(compareInsensitiveOrder('a', 'a') == 0)
assertTrue(compareInsensitiveOrder('a', 'A') == 0)
@@ -77,8 +77,8 @@ class Comparisons {
val list = listOf("aa", "b", "bb", "a")
val sorted = list.sortedWith(compareBy(
{ it.length },
{ it }
{ it.length },
{ it }
))
assertPrints(sorted, "[a, b, aa, bb]")
@@ -89,7 +89,7 @@ class Comparisons {
val list = listOf('B', 'a', 'A', 'b')
val sorted = list.sortedWith(
compareBy(String.CASE_INSENSITIVE_ORDER) { v -> v.toString() }
compareBy(String.CASE_INSENSITIVE_ORDER) { v -> v.toString() }
)
assertPrints(sorted, "[a, A, B, b]")
@@ -109,7 +109,7 @@ class Comparisons {
val list = listOf('B', 'a', 'A', 'b')
val sorted = list.sortedWith(
compareByDescending(String.CASE_INSENSITIVE_ORDER) { v -> v.toString() }
compareByDescending(String.CASE_INSENSITIVE_ORDER) { v -> v.toString() }
)
assertPrints(sorted, "[B, b, a, A]")
@@ -134,7 +134,7 @@ class Comparisons {
assertPrints(list.sortedWith(lengthComparator), "[A, b, a, aa, bb]")
val lengthThenCaseInsensitive = lengthComparator
.thenBy(String.CASE_INSENSITIVE_ORDER) { it }
.thenBy(String.CASE_INSENSITIVE_ORDER) { it }
assertPrints(list.sortedWith(lengthThenCaseInsensitive), "[A, a, b, aa, bb]")
}
@@ -157,7 +157,7 @@ class Comparisons {
assertPrints(list.sortedWith(lengthComparator), "[A, b, a, aa, bb]")
val lengthThenCaseInsensitive = lengthComparator
.thenByDescending(String.CASE_INSENSITIVE_ORDER) { it }
.thenByDescending(String.CASE_INSENSITIVE_ORDER) { it }
assertPrints(list.sortedWith(lengthThenCaseInsensitive), "[b, A, a, bb, aa]")
}
@@ -170,7 +170,7 @@ class Comparisons {
assertPrints(map1, "{d=0, null=0, c=1, a=1, b=2}")
val valueThenKeyComparator = valueComparator
.thenComparator({ a, b -> compareValues(a.first, b.first) })
.thenComparator({ a, b -> compareValues(a.first, b.first) })
val map2 = list.sortedWith(valueThenKeyComparator).toMap()
assertPrints(map2, "{null=0, d=0, a=1, c=1, b=2}")
}
@@ -180,7 +180,7 @@ class Comparisons {
val list = listOf("A", "aa", "b", "bb", "a")
val lengthThenCaseInsensitive = compareBy<String> { it.length }
.then(String.CASE_INSENSITIVE_ORDER)
.then(String.CASE_INSENSITIVE_ORDER)
val sorted = list.sortedWith(lengthThenCaseInsensitive)
@@ -192,7 +192,7 @@ class Comparisons {
val list = listOf("A", "aa", "b", "bb", "a")
val lengthThenCaseInsensitive = compareBy<String> { it.length }
.thenDescending(String.CASE_INSENSITIVE_ORDER)
.thenDescending(String.CASE_INSENSITIVE_ORDER)
val sorted = list.sortedWith(lengthThenCaseInsensitive)
@@ -226,7 +226,7 @@ class Comparisons {
val list = listOf("aa", "b", "bb", "a")
val lengthThenNatural = compareBy<String> { it.length }
.then(naturalOrder())
.then(naturalOrder())
val sorted = list.sortedWith(lengthThenNatural)
libraries/stdlib/test/ExceptionTest.kt
+6 -1
View File
@@ -29,7 +29,12 @@ class ExceptionTest {
@Test fun assertionError() = testCreateException(::AssertionError, ::AssertionError, ::AssertionError)
private fun <T : Throwable> testCreateException(noarg: () -> T, fromMessage: (String?) -> T, fromCause: ((Throwable?) -> T)? = null, fromMessageCause: ((String?, Throwable?) -> T)? = null) {
private fun <T : Throwable> testCreateException(
noarg: () -> T,
fromMessage: (String?) -> T,
fromCause: ((Throwable?) -> T)? = null,
fromMessageCause: ((String?, Throwable?) -> T)? = null
) {
noarg().let { e ->
assertEquals(null, e.message)
assertEquals(null, e.cause)
libraries/stdlib/test/OrderingTest.kt
+16 -11
View File
@@ -14,7 +14,8 @@ data class Item(val name: String, val rating: Int) : Comparable<Item> {
}
}
val STRING_CASE_INSENSITIVE_ORDER: Comparator<String> = compareBy { it: String -> it.toUpperCase() }.thenBy { it.toLowerCase() }.thenBy { it }
val STRING_CASE_INSENSITIVE_ORDER: Comparator<String> =
compareBy { it: String -> it.toUpperCase() }.thenBy { it.toLowerCase() }.thenBy { it }
class OrderingTest {
val v1 = Item("wine", 9)
@@ -72,13 +73,13 @@ class OrderingTest {
val byRating = compareBy<Item> { it.rating }
val v3 = Item(v1.name, v1.rating + 1)
val v4 = Item(v2.name + "_", v2.rating)
assertTrue( (byName then byRating).compare(v1, v2) > 0 )
assertTrue( (byName then byRating).compare(v1, v3) < 0 )
assertTrue( (byName thenDescending byRating).compare(v1, v3) > 0 )
assertTrue((byName then byRating).compare(v1, v2) > 0)
assertTrue((byName then byRating).compare(v1, v3) < 0)
assertTrue((byName thenDescending byRating).compare(v1, v3) > 0)
assertTrue( (byRating then byName).compare(v1, v2) < 0 )
assertTrue( (byRating then byName).compare(v4, v2) > 0 )
assertTrue( (byRating thenDescending byName).compare(v4, v2) < 0 )
assertTrue((byRating then byName).compare(v1, v2) < 0)
assertTrue((byRating then byName).compare(v4, v2) > 0)
assertTrue((byRating thenDescending byName).compare(v4, v2) < 0)
}
@Test
@@ -150,7 +151,8 @@ class OrderingTest {
assertEquals(v1, items[1])
}
@Test fun maxOf() {
@Test
fun maxOf() {
assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE))
assertEquals(Int.MAX_VALUE, maxOf(Int.MAX_VALUE, Int.MIN_VALUE, 0))
@@ -161,14 +163,16 @@ class OrderingTest {
assertEquals(Double.POSITIVE_INFINITY, maxOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE))
}
@Test fun maxOfWith() {
@Test
fun maxOfWith() {
assertEquals(v1, maxOf(v1, v2, compareBy { it.name }))
assertEquals(v1, maxOf(v3, v2, v1, compareBy { it.name }))
assertEquals(v2, maxOf(v1, v2, compareBy { it.rating }))
assertEquals(v3, maxOf(v1, v2, v3, compareBy { it.rating }))
}
@Test fun minOf() {
@Test
fun minOf() {
assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE))
assertEquals(Int.MIN_VALUE, minOf(Int.MAX_VALUE, Int.MIN_VALUE, 0))
@@ -179,7 +183,8 @@ class OrderingTest {
assertEquals(Double.MIN_VALUE, minOf(Double.POSITIVE_INFINITY, Double.MAX_VALUE, Double.MIN_VALUE))
}
@Test fun minOfWith() {
@Test
fun minOfWith() {
assertEquals(v2, minOf(v1, v2, compareBy { it.name }))
assertEquals(v3, minOf(v3, v2, v1, compareBy { it.name }))
assertEquals(v1, minOf(v1, v2, compareBy { it.rating }))
libraries/stdlib/test/collections/CollectionBehaviors.kt
+13 -13
View File
@@ -10,8 +10,8 @@ import test.collections.CompareContext
public fun <T> CompareContext<List<T>>.listBehavior() {
equalityBehavior()
collectionBehavior()
compareProperty( { listIterator() }, { listIteratorBehavior() })
compareProperty( { listIterator(0) }, { listIteratorBehavior() })
compareProperty({ listIterator() }, { listIteratorBehavior() })
compareProperty({ listIterator(0) }, { listIteratorBehavior() })
propertyFails { listIterator(-1) }
propertyFails { listIterator(size + 1) }
@@ -24,8 +24,8 @@ public fun <T> CompareContext<List<T>>.listBehavior() {
propertyEquals { indexOf(elementAtOrNull(0)) }
propertyEquals { lastIndexOf(elementAtOrNull(0)) }
propertyFails { subList(0, size + 1)}
propertyFails { subList(-1, 0)}
propertyFails { subList(0, size + 1) }
propertyFails { subList(-1, 0) }
propertyEquals { subList(0, size) }
}
@@ -73,7 +73,7 @@ public fun <K, V> CompareContext<Map<K, V>>.mapBehavior() {
propertyEquals { size }
propertyEquals { isEmpty() }
(object {}).let { propertyEquals { containsKey(it as Any?) } }
(object {}).let { propertyEquals { containsKey(it as Any?) } }
if (expected.isEmpty().not())
propertyEquals { contains(keys.first()) }
@@ -82,13 +82,13 @@ public fun <K, V> CompareContext<Map<K, V>>.mapBehavior() {
propertyEquals { containsValue(values.firstOrNull()) }
propertyEquals { get(null as Any?) }
compareProperty( { keys }, { setBehavior("keySet") } )
compareProperty( { entries }, { setBehavior("entrySet") } )
compareProperty( { values }, { collectionBehavior("values") })
compareProperty({ keys }, { setBehavior("keySet") })
compareProperty({ entries }, { setBehavior("entrySet") })
compareProperty({ values }, { collectionBehavior("values") })
}
public fun <T> CompareContext<T>.equalityBehavior(objectName: String = "") {
val prefix = objectName + if (objectName.isNotEmpty()) "." else ""
val prefix = objectName + if (objectName.isNotEmpty()) "." else ""
equals(objectName)
propertyEquals(prefix + "hashCode") { hashCode() }
propertyEquals(prefix + "toString") { toString() }
@@ -96,11 +96,11 @@ public fun <T> CompareContext<T>.equalityBehavior(objectName: String = "") {
public fun <T> CompareContext<Collection<T>>.collectionBehavior(objectName: String = "") {
val prefix = objectName + if (objectName.isNotEmpty()) "." else ""
propertyEquals (prefix + "size") { size }
propertyEquals (prefix + "isEmpty") { isEmpty() }
val prefix = objectName + if (objectName.isNotEmpty()) "." else ""
propertyEquals(prefix + "size") { size }
propertyEquals(prefix + "isEmpty") { isEmpty() }
(object {}).let { propertyEquals { contains(it as Any?) } }
(object {}).let { propertyEquals { contains(it as Any?) } }
propertyEquals { contains(firstOrNull()) }
propertyEquals { containsAll(this) }
}
libraries/stdlib/test/collections/ComparisonDSL.kt
+6 -2
View File
@@ -9,7 +9,7 @@ import test.*
import kotlin.reflect.KProperty1
import kotlin.test.*
public fun <T> compare(expected: T, actual: T, block:CompareContext<T>.() -> Unit) {
public fun <T> compare(expected: T, actual: T, block: CompareContext<T>.() -> Unit) {
CompareContext(expected, actual).block()
}
@@ -26,7 +26,11 @@ public class CompareContext<out T>(public val expected: T, public val actual: T)
public fun <P> propertyEquals(message: String = "", getter: T.() -> P) {
assertEquals(expected.getter(), actual.getter(), message)
}
public fun propertyFails(getter: T.() -> Unit) { assertFailEquals({expected.getter()}, {actual.getter()}) }
public fun propertyFails(getter: T.() -> Unit) {
assertFailEquals({ expected.getter() }, { actual.getter() })
}
public fun <P> compareProperty(getter: T.() -> P, block: CompareContext<P>.() -> Unit) {
compare(expected.getter(), actual.getter(), block)
}
libraries/stdlib/test/collections/GroupingTest.kt
+5 -5
View File
@@ -58,16 +58,16 @@ class GroupingTest {
val elements = listOf("foo", "bar", "flea", "zoo", "biscuit")
val result = elements.groupingBy { it.first() }
.fold({ k, _ -> Collector<Char, String>(k)}, { _, acc, e -> acc.accumulateIfEven(e) })
.fold({ k, _ -> Collector<Char, String>(k) }, { _, acc, e -> acc.accumulateIfEven(e) })
val ordered = result.values.sortedBy { it.key }.map { it.toPair() }
assertEquals(listOf('b' to emptyList(), 'f' to listOf("flea"), 'z' to emptyList()), ordered)
val moreElements = listOf("fire", "zero")
val result2 = moreElements.groupingBy { it.first() }
.foldTo(HashMap(result),
{ k, _ -> error("should not be called for $k") },
{ _, acc, e -> acc.accumulateIfEven(e) })
.foldTo(HashMap(result),
{ k, _ -> error("should not be called for $k") },
{ _, acc, e -> acc.accumulateIfEven(e) })
val ordered2 = result2.values.sortedBy { it.key }.map { it.toPair() }
assertEquals(listOf('b' to emptyList(), 'f' to listOf("flea", "fire"), 'z' to listOf("zero")), ordered2)
@@ -101,7 +101,7 @@ class GroupingTest {
assertEquals(mapOf('f' to 2, 'b' to 3, 'a' to 1, 'z' to 2), counts2)
}
/**
/*
@Test fun sumEach() {
val values = listOf("k" to 50, "b" to 20, "k" to 1000 )
val summary = values.groupingBy { it.first }.eachSumOf { it.second }
libraries/stdlib/test/collections/IterableTests.kt
+13 -9
View File
@@ -14,7 +14,7 @@ fun <T> Iterable<T>.toIterable(): Iterable<T> = Iterable { this.iterator() }
class IterableTest : OrderedIterableTests<Iterable<String>>({ iterableOf(*it) }, iterableOf<String>())
class SetTest : IterableTests<Set<String>>({ setOf(*it) }, setOf())
class LinkedSetTest : OrderedIterableTests<LinkedHashSet<String>>({ linkedSetOf(*it) }, linkedSetOf())
class ListTest : OrderedIterableTests<List<String>>( { listOf(*it) }, listOf<String>())
class ListTest : OrderedIterableTests<List<String>>({ listOf(*it) }, listOf<String>())
class ArrayListTest : OrderedIterableTests<ArrayList<String>>({ arrayListOf(*it) }, arrayListOf<String>())
abstract class OrderedIterableTests<T : Iterable<String>>(createFrom: (Array<out String>) -> T, empty: T) : IterableTests<T>(createFrom, empty) {
@@ -56,10 +56,10 @@ abstract class OrderedIterableTests<T : Iterable<String>>(createFrom: (Array<out
assertFails { data.elementAt(-1) }
assertFails { empty.elementAt(0) }
expect("foo") { data.elementAtOrElse(0, {""} )}
expect("zoo") { data.elementAtOrElse(-1, { "zoo" })}
expect("zoo") { data.elementAtOrElse(2, { "zoo" })}
expect("zoo") { empty.elementAtOrElse(0) { "zoo" }}
expect("foo") { data.elementAtOrElse(0, { "" }) }
expect("zoo") { data.elementAtOrElse(-1, { "zoo" }) }
expect("zoo") { data.elementAtOrElse(2, { "zoo" }) }
expect("zoo") { empty.elementAtOrElse(0) { "zoo" } }
expect(null) { empty.elementAtOrNull(0) }
@@ -239,7 +239,8 @@ abstract class IterableTests<T : Iterable<String>>(val createFrom: (Array<out St
assertEquals(listOf("foo"), foo)
}
@Test fun filterIndexed() {
@Test
fun filterIndexed() {
val result = data.filterIndexed { index, value -> value.first() == ('a' + index) }
assertEquals(listOf("bar"), result)
}
@@ -286,7 +287,7 @@ abstract class IterableTests<T : Iterable<String>>(val createFrom: (Array<out St
assertTrue(data === newData)
// static types test
assertStaticTypeIs<ArrayList<Int>>(arrayListOf(1, 2, 3).onEach { })
assertStaticTypeIs<ArrayList<Int>>(arrayListOf(1, 2, 3).onEach { })
}
@Test
@@ -490,7 +491,10 @@ abstract class IterableTests<T : Iterable<String>>(val createFrom: (Array<out St
}
fun <T> Iterable<T>.assertSorted(isInOrder: (T, T) -> Boolean): Unit { this.iterator().assertSorted(isInOrder) }
fun <T> Iterable<T>.assertSorted(isInOrder: (T, T) -> Boolean) {
this.iterator().assertSorted(isInOrder)
}
fun <T> Iterator<T>.assertSorted(isInOrder: (T, T) -> Boolean) {
if (!hasNext()) return
var index = 0
@@ -498,7 +502,7 @@ fun <T> Iterator<T>.assertSorted(isInOrder: (T, T) -> Boolean) {
while (hasNext()) {
index += 1
val next = next()
assertTrue(isInOrder(prev, next), "Not in order at position $index, element[${index-1}]: $prev, element[$index]: $next")
assertTrue(isInOrder(prev, next), "Not in order at position $index, element[${index - 1}]: $prev, element[$index]: $next")
prev = next
}
return
libraries/stdlib/test/collections/IteratorsTest.kt
+2 -1
View File
@@ -8,7 +8,8 @@ package test.collections
import kotlin.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/ListBinarySearchTest.kt
+2 -2
View File
@@ -82,7 +82,7 @@ class ListBinarySearchTest {
val list = values.map { IncomparableDataItem(IncomparableDataItem(it)) }
list.forEachIndexed { index, item ->
assertEquals(index, list.binarySearch { comparator.compare(it.value, item.value) } )
assertEquals(index, list.binarySearch { comparator.compare(it.value, item.value) })
assertEquals(notFound(index), list.binarySearch { comparator.compare(it.value, item.value.pred()) })
assertEquals(notFound(index + 1), list.binarySearch { comparator.compare(it.value, item.value.succ()) })
@@ -102,7 +102,7 @@ class ListBinarySearchTest {
val list = values.flatMap { v1 -> values.map { v2 -> Pair(v1, v2) } }
list.forEachIndexed { index, item ->
assertEquals(index, list.binarySearch { compareValuesBy(it, item, { it.first }, { it.second }) })
assertEquals(index, list.binarySearch { compareValuesBy(it, item, { it.first }, { it.second }) })
}
}
}
libraries/stdlib/test/collections/ListSpecificTest.kt
+4 -4
View File
@@ -43,10 +43,10 @@ class ListSpecificTest {
assertFails { data.get(-1) }
assertFails { empty.get(0) }
expect("foo") { data.getOrElse(0, {""} )}
expect("zoo") { data.getOrElse(-1, { "zoo" })}
expect("zoo") { data.getOrElse(2, { "zoo" })}
expect("zoo") { empty.getOrElse(0) { "zoo" }}
expect("foo") { data.getOrElse(0, { "" }) }
expect("zoo") { data.getOrElse(-1, { "zoo" }) }
expect("zoo") { data.getOrElse(2, { "zoo" }) }
expect("zoo") { empty.getOrElse(0) { "zoo" } }
expect(null) { empty.getOrNull(0) }
libraries/stdlib/test/collections/MutableCollectionsTest.kt
+8 -8
View File
@@ -9,15 +9,15 @@ import kotlin.test.*
class MutableCollectionTest {
fun <T, C: MutableCollection<T>> testOperation(before: List<T>, after: List<T>, expectedModified: Boolean, toMutableCollection: (List<T>) -> C)
= fun(operation: (C.() -> Boolean)) {
val list = toMutableCollection(before)
assertEquals(expectedModified, list.operation())
assertEquals(toMutableCollection(after), list)
}
fun <T, C : MutableCollection<T>> testOperation(before: List<T>, after: List<T>, expectedModified: Boolean, toMutableCollection: (List<T>) -> C) =
fun(operation: (C.() -> Boolean)) {
val list = toMutableCollection(before)
assertEquals(expectedModified, list.operation())
assertEquals(toMutableCollection(after), list)
}
fun <T> testOperation(before: List<T>, after: List<T>, expectedModified: Boolean)
= testOperation(before, after, expectedModified, { it.toMutableList() })
fun <T> testOperation(before: List<T>, after: List<T>, expectedModified: Boolean) =
testOperation(before, after, expectedModified, { it.toMutableList() })
@Test fun addAll() {
libraries/stdlib/test/collections/SequenceTest.kt
+14 -12
View File
@@ -90,10 +90,12 @@ public class SequenceTest {
@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 ->
if (index > 0 && (value % index) == 0) "$value/$index" else null
}.take(5).toList())
assertEquals(
listOf("1/1", "5/5", "144/12", "46368/24", "75025/25"),
fibonacci().mapIndexedNotNull { index, value ->
if (index > 0 && (value % index) == 0) "$value/$index" else null
}.take(5).toList()
)
}
@@ -457,14 +459,14 @@ public class SequenceTest {
@Test fun flatMapAndTakeExtractTheTransformedElements() {
val expected = listOf(
'3', // fibonacci(4) = 3
'5', // fibonacci(5) = 5
'8', // fibonacci(6) = 8
'1', '3', // fibonacci(7) = 13
'2', '1', // fibonacci(8) = 21
'3', '4', // fibonacci(9) = 34
'5' // fibonacci(10) = 55
)
'3', // fibonacci(4) = 3
'5', // fibonacci(5) = 5
'8', // fibonacci(6) = 8
'1', '3', // fibonacci(7) = 13
'2', '1', // fibonacci(8) = 21
'3', '4', // fibonacci(9) = 34
'5' // fibonacci(10) = 55
)
assertEquals(expected, fibonacci().drop(4).flatMap { it.toString().asSequence() }.take(10).toList())
}
libraries/stdlib/test/coroutines/CoroutineContextTest.kt
+1 -1
View File
@@ -154,7 +154,7 @@ class CoroutineContextTest {
assertNotEquals(ctx3, ctx4)
}
private fun assertContents(ctx: CoroutineContext, vararg elements: CoroutineContext.Element) {
private fun assertContents(ctx: CoroutineContext, vararg elements: CoroutineContext.Element) {
val set = ctx.fold(setOf<CoroutineContext>()) { a, b -> a + b }
assertEquals(listOf(*elements), set.toList())
for (elem in elements)
libraries/stdlib/test/coroutines/SequenceBuilderTest.kt
+12 -12
View File
@@ -261,18 +261,18 @@ class SequenceBuilderTest {
effects.add(")") // marks step end
}
assertEquals(
listOf(
"a",
"(", 1, ")",
"(", 2, ")",
"b", "c",
"(", 3, ")",
"d",
"(", 4, ")",
"e", "f",
"(", 5, ")"
),
effects.toList()
listOf(
"a",
"(", 1, ")",
"(", 2, ")",
"b", "c",
"(", 3, ")",
"d",
"(", 4, ")",
"e", "f",
"(", 5, ")"
),
effects.toList()
)
}
libraries/stdlib/test/js/MapJsTest.kt
+15 -5
View File
@@ -29,6 +29,7 @@ class ComplexMapJsTest : MapJsTest() {
override fun <T : kotlin.Comparable<T>> Collection<T>.toNormalizedList(): List<T> = this.sorted()
// hashMapOf returns ComlpexHashMap because it is Generic
override fun emptyMutableMap(): MutableMap<String, Int> = genericHashMapOf()
override fun emptyMutableMapWithNullableKeyValue(): MutableMap<String?, Int?> = genericHashMapOf()
}
@@ -107,24 +108,33 @@ abstract class MapJsTest {
val KEYS = listOf("zero", "one", "two", "three")
val VALUES = arrayOf(0, 1, 2, 3).toList()
val SPECIAL_NAMES = arrayOf("__proto__", "constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable")
val SPECIAL_NAMES = arrayOf(
"__proto__",
"constructor",
"toString",
"toLocaleString",
"valueOf",
"hasOwnProperty",
"isPrototypeOf",
"propertyIsEnumerable"
)
@Test fun getOrElse() {
val data = emptyMap()
val a = data.getOrElse("foo"){2}
val a = data.getOrElse("foo") { 2 }
assertEquals(2, a)
val b = data.getOrElse("foo"){3}
val b = data.getOrElse("foo") { 3 }
assertEquals(3, b)
assertEquals(0, data.size)
}
@Test fun getOrPut() {
val data = emptyMutableMap()
val a = data.getOrPut("foo"){2}
val a = data.getOrPut("foo") { 2 }
assertEquals(2, a)
val b = data.getOrPut("foo"){3}
val b = data.getOrPut("foo") { 3 }
assertEquals(2, b)
assertEquals(1, data.size)
libraries/stdlib/test/js/SetJsTest.kt
+13 -1
View File
@@ -29,6 +29,7 @@ class ComplexSetJsTest : SetJsTest() {
// hashSetOf returns ComlpexHashSet because it is Generic
override fun createEmptyMutableSet(): MutableSet<String> = genericHashSetOf()
override fun createEmptyMutableSetWithNullableValues(): MutableSet<String?> = genericHashSetOf()
@@ -92,7 +93,16 @@ abstract class SetJsTest {
val data: Set<String> = createTestMutableSet()
val empty: Set<String> = createEmptyMutableSet()
val SPECIAL_NAMES = arrayOf("__proto__", "constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable")
val SPECIAL_NAMES = arrayOf(
"__proto__",
"constructor",
"toString",
"toLocaleString",
"valueOf",
"hasOwnProperty",
"isPrototypeOf",
"propertyIsEnumerable"
)
@Test
fun size() {
@@ -270,6 +280,7 @@ abstract class SetJsTest {
//Helpers
abstract fun createEmptyMutableSet(): MutableSet<String>
abstract fun createEmptyMutableSetWithNullableValues(): MutableSet<String?>
fun createTestMutableSet(): MutableSet<String> {
@@ -278,6 +289,7 @@ abstract class SetJsTest {
set.add("bar")
return set
}
fun createTestMutableSetReversed(): MutableSet<String> {
val set = createEmptyMutableSet()
set.add("bar")
libraries/stdlib/test/numbers/MathTest.kt
+3 -4
View File
@@ -133,7 +133,7 @@ class DoubleMathTest {
assertEquals(0.25, 2.0.pow(-2))
assertTrue(0.0.pow(Double.NaN).isNaN())
assertTrue(Double.NaN.pow(-1).isNaN())
assertTrue((-7.0).pow(1/3.0).isNaN())
assertTrue((-7.0).pow(1 / 3.0).isNaN())
assertTrue(1.0.pow(Double.POSITIVE_INFINITY).isNaN())
assertTrue((-1.0).pow(Double.NEGATIVE_INFINITY).isNaN())
@@ -322,8 +322,7 @@ class DoubleMathTest {
val prev = value.nextDown()
if (prev > 0) {
assertEquals(value, prev + prev.ulp)
}
else {
} else {
assertEquals(prev, value - value.ulp)
}
@@ -472,7 +471,7 @@ class FloatMathTest {
assertEquals(0.25F, 2.0F.pow(-2))
assertTrue(0.0F.pow(Float.NaN).isNaN())
assertTrue(Float.NaN.pow(-1).isNaN())
assertTrue((-7.0F).pow(1/3.0F).isNaN())
assertTrue((-7.0F).pow(1 / 3.0F).isNaN())
assertTrue(1.0F.pow(Float.POSITIVE_INFINITY).isNaN())
assertTrue((-1.0F).pow(Float.NEGATIVE_INFINITY).isNaN())
libraries/stdlib/test/numbers/NaNPropagationTest.kt
+93 -51
View File
@@ -13,9 +13,11 @@ val Float.Companion.values get() = listOf(0.0f, NEGATIVE_INFINITY, MIN_VALUE, MA
class NaNPropagationTest {
private fun propagateOf2(f2d: (Double, Double) -> Double,
f2f: (Float, Float) -> Float,
function: String) {
private fun propagateOf2(
f2d: (Double, Double) -> Double,
f2f: (Float, Float) -> Float,
function: String
) {
with(Double) {
for (d in values) {
assertTrue(f2d(d, NaN).isNaN(), "$function($d, NaN)")
@@ -30,8 +32,10 @@ class NaNPropagationTest {
}
}
private fun propagateOf3(f3d: (Double, Double, Double) -> Double,
f3f: (Float, Float, Float) -> Float, function: String) {
private fun propagateOf3(
f3d: (Double, Double, Double) -> Double,
f3f: (Float, Float, Float) -> Float, function: String
) {
with(Double) {
for (d in values) {
@@ -49,62 +53,88 @@ class NaNPropagationTest {
}
}
@Test fun minOf() {
@Test
fun minOf() {
propagateOf2(::minOf, ::minOf, "minOf")
propagateOf3(::minOf, ::minOf, "minOf")
}
@Test fun maxOf() {
@Test
fun maxOf() {
propagateOf2(::maxOf, ::maxOf, "maxOf")
propagateOf3(::maxOf, ::maxOf, "maxOf")
}
@Test fun arrayMin() {
propagateOf2({ a, b -> arrayOf(a, b).min()!! },
{ a, b -> arrayOf(a, b).min()!! },
"arrayOf().min()")
@Test
fun arrayMin() {
propagateOf2(
{ a, b -> arrayOf(a, b).min()!! },
{ a, b -> arrayOf(a, b).min()!! },
"arrayOf().min()"
)
}
@Test fun arrayMax() {
propagateOf2({ a, b -> arrayOf(a, b).max()!! },
{ a, b -> arrayOf(a, b).max()!! },
"arrayOf().max()")
@Test
fun arrayMax() {
propagateOf2(
{ a, b -> arrayOf(a, b).max()!! },
{ a, b -> arrayOf(a, b).max()!! },
"arrayOf().max()"
)
}
@Test fun primitiveArrayMin() {
propagateOf2({ a, b -> doubleArrayOf(a, b).min()!! },
{ a, b -> floatArrayOf(a, b).min()!! },
"primitiveArrayOf().min()")
@Test
fun primitiveArrayMin() {
propagateOf2(
{ a, b -> doubleArrayOf(a, b).min()!! },
{ a, b -> floatArrayOf(a, b).min()!! },
"primitiveArrayOf().min()"
)
}
@Test fun primitiveArrayMax() {
propagateOf2({ a, b -> doubleArrayOf(a, b).max()!! },
{ a, b -> floatArrayOf(a, b).max()!! },
"primitiveArrayOf().max()")
@Test
fun primitiveArrayMax() {
propagateOf2(
{ a, b -> doubleArrayOf(a, b).max()!! },
{ a, b -> floatArrayOf(a, b).max()!! },
"primitiveArrayOf().max()"
)
}
@Test fun listMin() {
propagateOf2({ a, b -> listOf(a, b).min()!! },
{ a, b -> listOf(a, b).min()!! },
"listOf().min()")
@Test
fun listMin() {
propagateOf2(
{ a, b -> listOf(a, b).min()!! },
{ a, b -> listOf(a, b).min()!! },
"listOf().min()"
)
}
@Test fun listMax() {
propagateOf2({ a, b -> listOf(a, b).max()!! },
{ a, b -> listOf(a, b).max()!! },
"listOf().max()")
@Test
fun listMax() {
propagateOf2(
{ a, b -> listOf(a, b).max()!! },
{ a, b -> listOf(a, b).max()!! },
"listOf().max()"
)
}
@Test fun sequenceMin() {
propagateOf2({ a, b -> sequenceOf(a, b).min()!! },
{ a, b -> sequenceOf(a, b).min()!! },
"sequenceOf().min()")
@Test
fun sequenceMin() {
propagateOf2(
{ a, b -> sequenceOf(a, b).min()!! },
{ a, b -> sequenceOf(a, b).min()!! },
"sequenceOf().min()"
)
}
@Test fun sequenceMax() {
propagateOf2({ a, b -> sequenceOf(a, b).max()!! },
{ a, b -> sequenceOf(a, b).max()!! },
"sequenceOf().max()")
@Test
fun sequenceMax() {
propagateOf2(
{ a, b -> sequenceOf(a, b).max()!! },
{ a, b -> sequenceOf(a, b).max()!! },
"sequenceOf().max()"
)
}
}
@@ -113,7 +143,7 @@ class NaNTotalOrderTest {
private fun <T : Comparable<T>> totalOrderMinOf2(f2t: (T, T) -> T, function: String) {
@Suppress("UNCHECKED_CAST")
with (Double) {
with(Double) {
assertEquals<Any>(0.0, f2t(0.0 as T, NaN as T), "$function(0, NaN)")
assertEquals<Any>(0.0, f2t(NaN as T, 0.0 as T), "$function(NaN, 0)")
}
@@ -121,39 +151,51 @@ class NaNTotalOrderTest {
private fun <T : Comparable<T>> totalOrderMaxOf2(f2t: (T, T) -> T, function: String) {
@Suppress("UNCHECKED_CAST")
with (Double) {
with(Double) {
assertTrue((f2t(0.0 as T, NaN as T) as Double).isNaN(), "$function(0, NaN)")
assertTrue((f2t(NaN as T, 0.0 as T) as Double).isNaN(), "$function(NaN, 0)")
}
}
@Test fun minOfT() {
@Test
fun minOfT() {
totalOrderMinOf2<Comparable<Any>>(::minOf, "minOf")
}
@Test fun maxOfT() {
@Test
fun maxOfT() {
totalOrderMaxOf2<Comparable<Any>>(::maxOf, "maxOf")
}
@Test fun arrayTMin() {
@Test
fun arrayTMin() {
totalOrderMinOf2<Comparable<Any>>({ a, b -> arrayOf(a, b).min()!! }, "arrayOf().min()")
}
@Test fun arrayTMax() {
@Test
fun arrayTMax() {
totalOrderMaxOf2<Comparable<Any>>({ a, b -> arrayOf(a, b).max()!! }, "arrayOf().max()")
}
@Test fun listTMin() {
@Test
fun listTMin() {
totalOrderMinOf2<Comparable<Any>>({ a, b -> listOf(a, b).min()!! }, "listOf().min()")
}
@Test fun listTMax() {
@Test
fun listTMax() {
totalOrderMaxOf2<Comparable<Any>>({ a, b -> listOf(a, b).max()!! }, "listOf().max()")
}
@Test fun sequenceTMin() {
@Test
fun sequenceTMin() {
totalOrderMinOf2<Comparable<Any>>({ a, b -> sequenceOf(a, b).min()!! }, "sequenceOf().min()")
}
@Test fun sequenceTMax() {
@Test
fun sequenceTMax() {
totalOrderMaxOf2<Comparable<Any>>({ a, b -> sequenceOf(a, b).max()!! }, "sequenceOf().max()")
}
}
libraries/stdlib/test/properties/delegation/MapAccessorsTest.kt
+4 -4
View File
@@ -71,12 +71,12 @@ class VarByMapExtensionsTest {
@Test fun deprecatedAccessors() {
assertEquals<Int>(
expected = map.getValue(this, VarByMapExtensionsTest::c),
actual = map.getValue<Int>(this, VarByMapExtensionsTest::c)
expected = map.getValue(this, VarByMapExtensionsTest::c),
actual = map.getValue<Int>(this, VarByMapExtensionsTest::c)
)
assertEquals<String>(
expected = map2.getValue<CharSequence, String>(this, VarByMapExtensionsTest::a2),
actual = map2.getValue<String>(this, VarByMapExtensionsTest::a2)
expected = map2.getValue<CharSequence, String>(this, VarByMapExtensionsTest::a2),
actual = map2.getValue<String>(this, VarByMapExtensionsTest::a2)
)
}
}
libraries/stdlib/test/ranges/ProgressionLastElementTest.kt
+1 -1
View File
@@ -9,7 +9,7 @@ import kotlin.comparisons.*
import kotlin.test.*
class ProgressionLastElementTest {
class ProgressionLastElementTest {
private val MAX = Int.MAX_VALUE
private val MIN = Int.MIN_VALUE
libraries/stdlib/test/ranges/RangeIterationTest.kt
+5 -5
View File
@@ -11,11 +11,11 @@ import kotlin.test.*
public open class RangeIterationTestBase {
public fun <N : Any> doTest(
sequence: Iterable<N>,
expectedFirst: N,
expectedLast: N,
expectedIncrement: Number,
expectedElements: List<N>
sequence: Iterable<N>,
expectedFirst: N,
expectedLast: N,
expectedIncrement: Number,
expectedElements: List<N>
) {
val first: Any
val last: Any
libraries/stdlib/test/ranges/RangeTest.kt
+8 -8
View File
@@ -22,7 +22,7 @@ public class RangeTest {
assertFalse(10 in range)
assertFalse(9000 in range)
assertFalse(range.isEmpty())
assertTrue(9 in (range as ClosedRange<Int>))
@@ -92,7 +92,7 @@ public class RangeTest {
assertFalse(10.toShort() in range)
assertFalse(239.toShort() in range)
assertFalse(range.isEmpty())
assertTrue(1.toByte() in range)
@@ -125,7 +125,7 @@ public class RangeTest {
assertFalse(10L in range)
assertFalse(10000000L in range)
assertFalse(range.isEmpty())
assertTrue(9 in (range as ClosedRange<Long>))
@@ -162,7 +162,7 @@ public class RangeTest {
assertFalse('z' in range)
assertFalse('\u1000' in range)
assertFalse(range.isEmpty())
assertTrue('v' in (range as ClosedRange<Char>))
@@ -357,26 +357,26 @@ public class RangeTest {
assertFailsWithIllegalArgument { 0..5 step 0 }
assertFailsWithIllegalArgument { 0.toByte()..5.toByte() step 0 }
assertFailsWithIllegalArgument { 0.toShort()..5.toShort() step 0 }
assertFailsWithIllegalArgument { 0.toShort()..5.toShort() step 0 }
assertFailsWithIllegalArgument { 0L..5L step 0L }
assertFailsWithIllegalArgument { 'a'..'z' step 0 }
assertFailsWithIllegalArgument { 0 downTo -5 step 0 }
assertFailsWithIllegalArgument { 0.toByte() downTo -5.toByte() step 0 }
assertFailsWithIllegalArgument { 0.toShort() downTo -5.toShort() step 0 }
assertFailsWithIllegalArgument { 0.toShort() downTo -5.toShort() step 0 }
assertFailsWithIllegalArgument { 0L downTo -5L step 0L }
assertFailsWithIllegalArgument { 'z' downTo 'a' step 0 }
assertFailsWithIllegalArgument { 0..5 step -2 }
assertFailsWithIllegalArgument { 0.toByte()..5.toByte() step -2 }
assertFailsWithIllegalArgument { 0.toShort()..5.toShort() step -2 }
assertFailsWithIllegalArgument { 0.toShort()..5.toShort() step -2 }
assertFailsWithIllegalArgument { 0L..5L step -2L }
assertFailsWithIllegalArgument { 'a'..'z' step -2 }
assertFailsWithIllegalArgument { 0 downTo -5 step -2 }
assertFailsWithIllegalArgument { 0.toByte() downTo -5.toByte() step -2 }
assertFailsWithIllegalArgument { 0.toShort() downTo -5.toShort() step -2 }
assertFailsWithIllegalArgument { 0.toShort() downTo -5.toShort() step -2 }
assertFailsWithIllegalArgument { 0L downTo -5L step -2L }
assertFailsWithIllegalArgument { 'z' downTo 'a' step -2 }
}
libraries/stdlib/test/text/RegexTest.kt
+1 -1
View File
@@ -187,7 +187,7 @@ class RegexTest {
@Test fun replaceEvaluator() {
val input = "/12/456/7890/"
val pattern = "\\d+".toRegex()
assertEquals("/2/3/4/", pattern.replace(input, { it.value.length.toString() } ))
assertEquals("/2/3/4/", pattern.replace(input, { it.value.length.toString() }))
}
libraries/stdlib/test/text/StringNumberConversionTest.kt
+20 -12
View File
@@ -157,24 +157,30 @@ class StringNumberConversionTest {
internal fun doubleTotalOrderEquals(a: Double?, b: Double?): Boolean = (a as Any?) == b
internal fun <T : Any> compareConversion(convertOrFail: (String) -> T,
convertOrNull: (String) -> T?,
equality: (T, T?) -> Boolean = { a, b -> a == b },
assertions: ConversionContext<T>.() -> Unit) {
internal fun <T : Any> compareConversion(
convertOrFail: (String) -> T,
convertOrNull: (String) -> T?,
equality: (T, T?) -> Boolean = { a, b -> a == b },
assertions: ConversionContext<T>.() -> Unit
) {
ConversionContext(convertOrFail, convertOrNull, equality).assertions()
}
internal fun <T : Any> compareConversionWithRadix(convertOrFail: String.(Int) -> T,
convertOrNull: String.(Int) -> T?,
assertions: ConversionWithRadixContext<T>.() -> Unit) {
internal fun <T : Any> compareConversionWithRadix(
convertOrFail: String.(Int) -> T,
convertOrNull: String.(Int) -> T?,
assertions: ConversionWithRadixContext<T>.() -> Unit
) {
ConversionWithRadixContext(convertOrFail, convertOrNull).assertions()
}
internal class ConversionContext<T: Any>(val convertOrFail: (String) -> T,
val convertOrNull: (String) -> T?,
val equality: (T, T?) -> Boolean) {
internal class ConversionContext<T : Any>(
val convertOrFail: (String) -> T,
val convertOrNull: (String) -> T?,
val equality: (T, T?) -> Boolean
) {
private fun assertEquals(expected: T, actual: T?, input: String, operation: String) {
assertTrue(equality(expected, actual), "Expected $operation('$input') to produce $expected but was $actual")
@@ -191,8 +197,10 @@ internal class ConversionContext<T: Any>(val convertOrFail: (String) -> T,
}
}
internal class ConversionWithRadixContext<T: Any>(val convertOrFail: (String, Int) -> T,
val convertOrNull: (String, Int) -> T?) {
internal class ConversionWithRadixContext<T : Any>(
val convertOrFail: (String, Int) -> T,
val convertOrNull: (String, Int) -> T?
) {
fun assertProduces(radix: Int, input: String, output: T) {
assertEquals(output, convertOrFail(input.removeLeadingPlusOnJava6(), radix))
assertEquals(output, convertOrNull(input, radix))
libraries/stdlib/test/text/StringTest.kt
+41 -32
View File
@@ -21,8 +21,9 @@ fun withOneCharSequenceArg(f: ((String) -> CharSequence) -> Unit) {
for (arg1Builder in charSequenceBuilders) f(arg1Builder)
}
fun withOneCharSequenceArg(arg1: String, f: (CharSequence) -> Unit)
= withOneCharSequenceArg { arg1Builder -> f(arg1Builder(arg1)) }
fun withOneCharSequenceArg(arg1: String, f: (CharSequence) -> Unit) {
withOneCharSequenceArg { arg1Builder -> f(arg1Builder(arg1)) }
}
fun withTwoCharSequenceArgs(f: ((String) -> CharSequence, (String) -> CharSequence) -> Unit) {
for (arg1Builder in charSequenceBuilders)
@@ -35,6 +36,7 @@ fun assertContentEquals(expected: String, actual: CharSequence, message: String?
}
// helper predicates available on both platforms
fun Char.isAsciiDigit() = this in '0'..'9'
fun Char.isAsciiLetter() = this in 'A'..'Z' || this in 'a'..'z'
fun Char.isAsciiUpperCase() = this in 'A'..'Z'
@@ -55,8 +57,7 @@ class StringTest {
val value = case.value?.let { arg1(it) }
assertEquals(case.isNull || case.isEmpty, value.isNullOrEmpty(), "failed for case '$value'")
assertEquals(case.isNull || case.isBlank, value.isNullOrBlank(), "failed for case '$value'")
if (value != null)
{
if (value != null) {
assertEquals(case.isEmpty, value.isEmpty(), "failed for case '$value'")
assertEquals(case.isBlank, value.isBlank(), "failed for case '$value'")
}
@@ -116,7 +117,7 @@ class StringTest {
@Test fun endsWithStringForCharSequence() = withTwoCharSequenceArgs { arg1, arg2 ->
fun String.endsWithCs(suffix: String, ignoreCase: Boolean = false): Boolean =
arg1(this).endsWith(arg2(suffix), ignoreCase)
assertTrue("abcd".endsWithCs("d"))
assertTrue("abcd".endsWithCs("abcd"))
assertFalse("abcd".endsWithCs("b"))
@@ -265,7 +266,7 @@ class StringTest {
assertContentEquals("sae text", s.removeRange(2, 5))
assertContentEquals("sa text", s.removeRange(2..5))
assertContentEquals(s.toString(), s.removeRange(2,2))
assertContentEquals(s.toString(), s.removeRange(2, 2))
// symmetry with indices
assertContentEquals("", s.removeRange(s.indices))
@@ -337,7 +338,7 @@ class StringTest {
@Test fun stringIterator() = withOneCharSequenceArg("239") { data ->
var sum = 0
for(c in data)
for (c in data)
sum += (c - '0')
assertTrue(sum == 14)
}
@@ -358,8 +359,8 @@ class StringTest {
assertContentEquals("a", "\ra".trimStartCS())
assertContentEquals("a", "\na".trimStartCS())
assertContentEquals("a=", arg1("-=-=a=").trimStart('-','='))
assertContentEquals("123a", arg1("ab123a").trimStart { !it.isAsciiDigit() })
assertContentEquals("a=", arg1("-=-=a=").trimStart('-', '='))
assertContentEquals("123a", arg1("ab123a").trimStart { !it.isAsciiDigit() })
}
@Test fun trimEnd() = withOneCharSequenceArg { arg1 ->
@@ -378,20 +379,21 @@ class StringTest {
assertContentEquals("a", "a\r".trimEndCS())
assertContentEquals("a", "a\n".trimEndCS())
assertContentEquals("=a", arg1("=a=-=-").trimEnd('-','='))
assertContentEquals("=a", arg1("=a=-=-").trimEnd('-', '='))
assertContentEquals("ab123", arg1("ab123a").trimEnd { !it.isAsciiDigit() })
}
@Test fun trimStartAndEnd() = withOneCharSequenceArg { arg1 ->
val examples = arrayOf("a",
" a ",
" a ",
" a b ",
"\ta\tb\t",
"\t\ta\t\t",
"\ra\r",
"\na\n",
" \u00A0 a \u00A0 "
val examples = arrayOf(
"a",
" a ",
" a ",
" a b ",
"\ta\tb\t",
"\t\ta\t\t",
"\ra\r",
"\na\n",
" \u00A0 a \u00A0 "
)
for ((source, example) in examples.map { it to arg1(it) }) {
@@ -399,8 +401,9 @@ class StringTest {
assertContentEquals(source.trimStart().trimEnd(), example.trim())
}
val examplesForPredicate = arrayOf("123",
"-=123=-"
val examplesForPredicate = arrayOf(
"123",
"-=123=-"
)
val trimChars = charArrayOf('-', '=')
@@ -676,9 +679,15 @@ class StringTest {
assertEquals(2, string.lastIndexOf('e', 3, ignoreCase = true))
for (startIndex in -1..string.length+1){
assertEquals(string.indexOfAny(charArrayOf('e'), startIndex, ignoreCase = true), string.indexOf('E', startIndex, ignoreCase = true))
assertEquals(string.lastIndexOfAny(charArrayOf('E'), startIndex, ignoreCase = true), string.lastIndexOf('e', startIndex, ignoreCase = true))
for (startIndex in -1..string.length + 1) {
assertEquals(
string.indexOfAny(charArrayOf('e'), startIndex, ignoreCase = true),
string.indexOf('E', startIndex, ignoreCase = true)
)
assertEquals(
string.lastIndexOfAny(charArrayOf('E'), startIndex, ignoreCase = true),
string.lastIndexOf('e', startIndex, ignoreCase = true)
)
}
}
@@ -738,8 +747,8 @@ class StringTest {
@Test fun replaceFirst() {
val input = "AbbabA"
assertEquals("Abb${'$'}bA", input.replaceFirst('a','$'))
assertEquals("${'$'}bbabA", input.replaceFirst('a','$', ignoreCase = true))
assertEquals("Abb${'$'}bA", input.replaceFirst('a', '$'))
assertEquals("${'$'}bbabA", input.replaceFirst('a', '$', ignoreCase = true))
// doesn't pass in Rhino JS
// assertEquals("schrodinger", "schrÖdinger".replaceFirst('ö', 'o', ignoreCase = true))
@@ -789,8 +798,8 @@ class StringTest {
assertTrue(data === newData)
// static types test
assertStaticTypeIs<String>("x".onEach { })
assertStaticTypeIs<StringBuilder>(result.onEach { })
assertStaticTypeIs<String>("x".onEach { })
assertStaticTypeIs<StringBuilder>(result.onEach { })
}
@@ -989,7 +998,7 @@ class StringTest {
@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 } )
val result = data.fold(0, { digits, c -> if (c.isAsciiDigit()) digits + 1 else digits })
assertEquals(3, result)
//simulate all method
@@ -1002,7 +1011,7 @@ class StringTest {
@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 })
val result = data.foldRight(0, { c, digits -> if (c.isAsciiDigit()) digits + 1 else digits })
assertEquals(3, result)
//simulate all method
@@ -1070,8 +1079,8 @@ class StringTest {
// group characters by their case
val result = data.groupBy { it.isAsciiUpperCase() }
assertEquals(2, result.size)
assertEquals(listOf('a','b','b','a','c'), result[false])
assertEquals(listOf('A','A','B','D'), result[true])
assertEquals(listOf('a', 'b', 'b', 'a', 'c'), result[false])
assertEquals(listOf('A', 'A', 'B', 'D'), result[true])
}
@Test fun joinToString() {
libraries/stdlib/test/utils/KotlinVersionTest.kt
+1 -2
View File
@@ -29,8 +29,7 @@ class KotlinVersionTest {
val (major, minor, patch) = IntArray(3) { index -> if (index == place) component else 0 }
if (component in 0..KotlinVersion.MAX_COMPONENT_VALUE) {
KotlinVersion(major, minor, patch)
}
else {
} else {
assertFailsWith<IllegalArgumentException>("Expected $major.$minor.$patch to be invalid version") {
KotlinVersion(major, minor, patch)
}
libraries/stdlib/test/utils/TODOTest.kt
+4 -2
View File
@@ -13,6 +13,7 @@ class TODOTest {
public val prop: String get() = TODO()
@Suppress("UNREACHABLE_CODE", "CAST_NEVER_SUCCEEDS")
fun method1() = TODO() as String
public fun method2(): Int = TODO()
public fun method3(switch: Boolean, value: String): String {
@@ -41,11 +42,12 @@ class TODOTest {
}
@Test fun usage() {
@Test
fun usage() {
val inst = PartiallyImplementedClass()
assertNotImplemented { inst.prop }
assertNotImplemented{ inst.method1() }
assertNotImplemented { inst.method1() }
assertNotImplemented { inst.method2() }
assertNotImplemented { inst.method4() }
assertNotImplementedWithMessage("what if false") { inst.method3(false, "test") }