stdlib tests: move JVM-only test source files
This commit is contained in:
Ilya Gorbunov
@@ -1,206 +0,0 @@
|
||||
@file:kotlin.jvm.JvmVersion
|
||||
package test.collections
|
||||
|
||||
import test.assertStaticAndRuntimeTypeIs
|
||||
import kotlin.test.*
|
||||
import kotlin.comparisons.*
|
||||
import java.util.*
|
||||
|
||||
import test.io.deserializeFromHex
|
||||
import test.io.serializeAndDeserialize
|
||||
|
||||
class CollectionJVMTest {
|
||||
|
||||
private fun <T> identitySetOf(vararg values: T): MutableSet<T> {
|
||||
val map = IdentityHashMap<T, String>()
|
||||
values.forEach { map.put(it, "") }
|
||||
return map.keys
|
||||
}
|
||||
|
||||
private data class IdentityData(public val value: Int)
|
||||
|
||||
@Test fun removeAllWithDifferentEquality() {
|
||||
val data = listOf(IdentityData(1), IdentityData(1))
|
||||
val list = data.toMutableList()
|
||||
list -= identitySetOf(data[0]) as Iterable<IdentityData>
|
||||
assertTrue(list.single() === data[1], "Identity contains should be used")
|
||||
|
||||
val list2 = data.toMutableList()
|
||||
list2 -= hashSetOf(data[0]) as Iterable<IdentityData>
|
||||
assertTrue(list2.isEmpty(), "Equality contains should be used")
|
||||
|
||||
val set3: MutableSet<IdentityData> = identitySetOf(*data.toTypedArray())
|
||||
set3 -= arrayOf(data[1])
|
||||
assertTrue(set3.isEmpty(), "Array doesn't have contains, equality contains is used instead")
|
||||
}
|
||||
|
||||
@Test fun flatMap() {
|
||||
val data = listOf("", "foo", "bar", "x", "")
|
||||
val characters = data.flatMap { it.toList() }
|
||||
println("Got list of characters ${characters}")
|
||||
assertEquals(7, characters.size)
|
||||
val text = characters.joinToString("")
|
||||
assertEquals("foobarx", text)
|
||||
}
|
||||
|
||||
|
||||
@Test fun filterIntoLinkedList() {
|
||||
val data = listOf("foo", "bar")
|
||||
val foo = data.filterTo(LinkedList<String>()) { it.startsWith("f") }
|
||||
|
||||
assertTrue {
|
||||
foo.all { it.startsWith("f") }
|
||||
}
|
||||
assertEquals(1, foo.size)
|
||||
assertEquals(listOf("foo"), foo)
|
||||
|
||||
assertStaticAndRuntimeTypeIs<LinkedList<String>>(foo)
|
||||
}
|
||||
|
||||
@Test fun filterNotIntoLinkedListOf() {
|
||||
val data = listOf("foo", "bar")
|
||||
val foo = data.filterNotTo(LinkedList<String>()) { it.startsWith("f") }
|
||||
|
||||
assertTrue {
|
||||
foo.all { !it.startsWith("f") }
|
||||
}
|
||||
assertEquals(1, foo.size)
|
||||
assertEquals(listOf("bar"), foo)
|
||||
|
||||
assertStaticAndRuntimeTypeIs<LinkedList<String>>(foo)
|
||||
}
|
||||
|
||||
@Test fun filterNotNullIntoLinkedListOf() {
|
||||
val data = listOf(null, "foo", null, "bar")
|
||||
val foo = data.filterNotNullTo(LinkedList<String>())
|
||||
|
||||
assertEquals(2, foo.size)
|
||||
assertEquals(LinkedList(listOf("foo", "bar")), foo)
|
||||
|
||||
assertStaticAndRuntimeTypeIs<LinkedList<String>>(foo)
|
||||
}
|
||||
|
||||
@Test fun filterIntoSortedSet() {
|
||||
val data = listOf("foo", "bar")
|
||||
val sorted = data.filterTo(sortedSetOf<String>()) { it.length == 3 }
|
||||
assertEquals(2, sorted.size)
|
||||
assertEquals(sortedSetOf("bar", "foo"), sorted)
|
||||
|
||||
assertStaticAndRuntimeTypeIs<TreeSet<String>>(sorted)
|
||||
}
|
||||
|
||||
@Test fun first() {
|
||||
assertEquals(19, TreeSet(listOf(90, 47, 19)).first())
|
||||
}
|
||||
|
||||
@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() {
|
||||
assertFails { LinkedList<String>().last() }
|
||||
}
|
||||
|
||||
@Test fun contains() {
|
||||
assertTrue(LinkedList(listOf(15, 19, 20)).contains(15))
|
||||
}
|
||||
|
||||
@Test fun toArray() {
|
||||
val data = listOf("foo", "bar")
|
||||
val arr = data.toTypedArray()
|
||||
println("Got array ${arr}")
|
||||
assertEquals(2, arr.size)
|
||||
todo {
|
||||
assertTrue {
|
||||
arr.isArrayOf<String>()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun toSortedSet() {
|
||||
val data = listOf("foo", "Foo", "bar")
|
||||
val set1 = data.toSortedSet()
|
||||
assertEquals(listOf("Foo", "bar", "foo"), set1.toList())
|
||||
|
||||
val set2 = data.toSortedSet(reverseOrder())
|
||||
assertEquals(listOf("foo", "bar", "Foo"), set2.toList())
|
||||
|
||||
val set3 = data.toSortedSet(String.CASE_INSENSITIVE_ORDER)
|
||||
assertEquals(listOf("bar", "foo"), set3.toList())
|
||||
}
|
||||
|
||||
@Test fun takeReturnsFirstNElements() {
|
||||
expect(setOf(1, 2)) { sortedSetOf(1, 2, 3, 4, 5).take(2).toSet() }
|
||||
}
|
||||
|
||||
@Test fun filterIsInstanceList() {
|
||||
val values: List<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde")
|
||||
|
||||
val intValues: List<Int> = values.filterIsInstance<Int>()
|
||||
assertEquals(listOf(1, 2), intValues)
|
||||
|
||||
val doubleValues: List<Double> = values.filterIsInstance<Double>()
|
||||
assertEquals(listOf(3.0), doubleValues)
|
||||
|
||||
val stringValues: List<String> = values.filterIsInstance<String>()
|
||||
assertEquals(listOf("abc", "cde"), stringValues)
|
||||
|
||||
val anyValues: List<Any> = values.filterIsInstance<Any>()
|
||||
assertEquals(values.toList(), anyValues)
|
||||
|
||||
val charValues: List<Char> = values.filterIsInstance<Char>()
|
||||
assertEquals(0, charValues.size)
|
||||
}
|
||||
|
||||
@Test fun filterIsInstanceArray() {
|
||||
val src: Array<Any> = arrayOf(1, 2, 3.toDouble(), "abc", "cde")
|
||||
|
||||
val intValues: List<Int> = src.filterIsInstance<Int>()
|
||||
assertEquals(listOf(1, 2), intValues)
|
||||
|
||||
val doubleValues: List<Double> = src.filterIsInstance<Double>()
|
||||
assertEquals(listOf(3.0), doubleValues)
|
||||
|
||||
val stringValues: List<String> = src.filterIsInstance<String>()
|
||||
assertEquals(listOf("abc", "cde"), stringValues)
|
||||
|
||||
val anyValues: List<Any> = src.filterIsInstance<Any>()
|
||||
assertEquals(src.toList(), anyValues)
|
||||
|
||||
val charValues: List<Char> = src.filterIsInstance<Char>()
|
||||
assertEquals(0, charValues.size)
|
||||
}
|
||||
|
||||
@Test fun emptyListIsSerializable() = testSingletonSerialization(emptyList<Any>())
|
||||
|
||||
@Test fun emptySetIsSerializable() = testSingletonSerialization(emptySet<Any>())
|
||||
|
||||
@Test fun emptyMapIsSerializable() = testSingletonSerialization(emptyMap<Any, Any>())
|
||||
|
||||
private fun testSingletonSerialization(value: Any) {
|
||||
val result = serializeAndDeserialize(value)
|
||||
|
||||
assertEquals(value, result)
|
||||
assertTrue(value === result)
|
||||
}
|
||||
|
||||
@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(
|
||||
"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>())
|
||||
|
||||
private fun testPersistedDeserialization(hexValue: String, expected: Any) {
|
||||
val actual = deserializeFromHex<Any>(hexValue)
|
||||
assertEquals(expected, actual)
|
||||
}
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2017 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
@file:kotlin.jvm.JvmVersion
|
||||
package test.collections
|
||||
|
||||
import java.util.*
|
||||
|
||||
class LinkedListTest : OrderedIterableTests<LinkedList<String>>( { LinkedList(it.asList()) }, LinkedList<String>())
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
@file:kotlin.jvm.JvmVersion
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
import java.util.*
|
||||
|
||||
class IteratorsJVMTest {
|
||||
|
||||
@Test fun testEnumeration() {
|
||||
val v = Vector<Int>()
|
||||
for (i in 1..5)
|
||||
v.add(i)
|
||||
|
||||
var sum = 0
|
||||
for (k in v.elements())
|
||||
sum += k
|
||||
|
||||
assertEquals(15, sum)
|
||||
}
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
@file:kotlin.jvm.JvmVersion
|
||||
package test.collections
|
||||
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
import java.util.concurrent.ConcurrentMap
|
||||
import kotlin.test.*
|
||||
import kotlin.comparisons.*
|
||||
|
||||
class MapJVMTest {
|
||||
@Test fun createSortedMap() {
|
||||
val map = sortedMapOf(Pair("c", 3), Pair("b", 2), Pair("a", 1))
|
||||
assertEquals(1, map["a"])
|
||||
assertEquals(2, map["b"])
|
||||
assertEquals(3, map["c"])
|
||||
assertEquals(listOf("a", "b", "c"), map.keys.toList())
|
||||
}
|
||||
|
||||
@Test fun toSortedMap() {
|
||||
val map = mapOf(Pair("c", 3), Pair("b", 2), Pair("a", 1))
|
||||
val sorted = map.toSortedMap()
|
||||
assertEquals(1, sorted["a"])
|
||||
assertEquals(2, sorted["b"])
|
||||
assertEquals(3, sorted["c"])
|
||||
assertEquals(listOf("a", "b", "c"), sorted.keys.toList())
|
||||
}
|
||||
|
||||
@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())
|
||||
assertEquals(1, sorted["abc"])
|
||||
assertEquals(2, sorted["bc"])
|
||||
assertEquals(3, sorted["c"])
|
||||
}
|
||||
|
||||
@Test fun toProperties() {
|
||||
val map = mapOf("a" to "A", "b" to "B")
|
||||
val prop = map.toProperties()
|
||||
assertEquals(2, prop.size)
|
||||
assertEquals("A", prop.getProperty("a", "fail"))
|
||||
assertEquals("B", prop.getProperty("b", "fail"))
|
||||
}
|
||||
|
||||
@Test fun iterateAndRemove() {
|
||||
val map = (1..5).associateByTo(linkedMapOf(), { it }, { 'a' + it })
|
||||
val iterator = map.iterator()
|
||||
while (iterator.hasNext()) {
|
||||
if (iterator.next().key % 2 == 0)
|
||||
iterator.remove()
|
||||
}
|
||||
assertEquals(listOf(1, 3, 5), map.keys.toList())
|
||||
assertEquals(listOf('b', 'd', 'f'), map.values.toList())
|
||||
}
|
||||
|
||||
@Test fun getOrPutFailsOnConcurrentMap() {
|
||||
val map = ConcurrentHashMap<String, Int>()
|
||||
|
||||
// not an error anymore
|
||||
expect(1) {
|
||||
map.getOrPut("x") { 1 }
|
||||
}
|
||||
expect(1) {
|
||||
(map as MutableMap<String, Int>).getOrPut("x") { 1 }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
|
||||
* that can be found in the license/LICENSE.txt file.
|
||||
*/
|
||||
|
||||
@file:JvmVersion
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
|
||||
class MutableCollectionJVMTest {
|
||||
|
||||
@Test fun shuffledRnd() {
|
||||
val rnd1 = java.util.Random(42L)
|
||||
val rnd2 = java.util.Random(42L)
|
||||
|
||||
val list = MutableList(100) { it }
|
||||
val shuffled1 = list.shuffled(rnd1)
|
||||
val shuffled2 = list.shuffled(rnd2)
|
||||
|
||||
|
||||
assertNotEquals(list, shuffled1)
|
||||
assertEquals(list.toSet(), shuffled1.toSet())
|
||||
assertEquals(list.size, shuffled1.distinct().size)
|
||||
|
||||
assertEquals(shuffled1, shuffled2)
|
||||
}
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
@file:kotlin.jvm.JvmVersion
|
||||
package test.collections
|
||||
|
||||
import kotlin.test.*
|
||||
|
||||
class SequenceJVMTest {
|
||||
|
||||
@Test fun filterIsInstance() {
|
||||
val src: Sequence<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde").asSequence()
|
||||
|
||||
val intValues: Sequence<Int> = src.filterIsInstance<Int>()
|
||||
assertEquals(listOf(1, 2), intValues.toList())
|
||||
|
||||
val doubleValues: Sequence<Double> = src.filterIsInstance<Double>()
|
||||
assertEquals(listOf(3.0), doubleValues.toList())
|
||||
|
||||
val stringValues: Sequence<String> = src.filterIsInstance<String>()
|
||||
assertEquals(listOf("abc", "cde"), stringValues.toList())
|
||||
|
||||
val anyValues: Sequence<Any> = src.filterIsInstance<Any>()
|
||||
assertEquals(src.toList(), anyValues.toList())
|
||||
|
||||
val charValues: Sequence<Char> = src.filterIsInstance<Char>()
|
||||
assertEquals(0, charValues.toList().size)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user