Restore kotlin-stdlib-jre7/8 libraries
This commit is contained in:
Alexander Udalov
committed by
Ilya Gorbunov
Ilya Gorbunov
parent
e253acd5fd
commit
537a0ce315
@@ -0,0 +1,48 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package kotlin.jdk8.collections.test
|
||||
|
||||
import org.junit.Test
|
||||
import kotlin.test.*
|
||||
import java.util.function.Predicate
|
||||
import java.util.stream.Collectors
|
||||
import kotlin.streams.*
|
||||
|
||||
class CollectionTest {
|
||||
|
||||
val data = listOf("abc", "fo", "baar")
|
||||
|
||||
@Test fun stream() {
|
||||
assertEquals(
|
||||
data.flatMap { it.asIterable() },
|
||||
data.stream()
|
||||
.flatMap { it.chars().boxed().map { it.toChar() } }
|
||||
.collect(Collectors.toList()))
|
||||
|
||||
assertEquals(data, data.parallelStream().toList())
|
||||
}
|
||||
|
||||
|
||||
@Test fun removeIf() {
|
||||
val coll: MutableCollection<String> = data.toMutableList()
|
||||
assertTrue(coll.removeIf { it.length < 3 })
|
||||
assertEquals(listOf("abc", "baar"), coll as Collection<String>)
|
||||
assertFalse(coll.removeIf(Predicate { it.length > 4 }))
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package kotlin.jdk8.collections.test
|
||||
|
||||
import org.junit.Test
|
||||
import kotlin.test.*
|
||||
import java.util.function.*
|
||||
|
||||
class IterableTest {
|
||||
|
||||
val data = listOf("foo", "bar")
|
||||
val iterable = Iterable { data.iterator() }
|
||||
|
||||
@Test fun spliterator() {
|
||||
val spliterator = iterable.spliterator()
|
||||
|
||||
assertEquals(-1, spliterator.exactSizeIfKnown)
|
||||
val expected = data.toMutableList()
|
||||
spliterator.forEachRemaining {
|
||||
assertEquals(expected.removeAt(0), it)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun forEach() {
|
||||
val expected = data.toMutableList()
|
||||
iterable.forEach(Consumer {
|
||||
assertEquals(expected.removeAt(0), it)
|
||||
})
|
||||
}
|
||||
|
||||
@Test fun forEachRemaining() {
|
||||
val expected = data.toMutableList()
|
||||
val iterator = iterable.iterator()
|
||||
iterator.forEachRemaining(Consumer {
|
||||
assertEquals(expected.removeAt(0), it)
|
||||
})
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package kotlin.jdk8.collections.test
|
||||
|
||||
import org.junit.Test
|
||||
import kotlin.test.*
|
||||
import java.util.function.UnaryOperator
|
||||
|
||||
class ListTest {
|
||||
|
||||
@Test fun replaceAll() {
|
||||
val list = mutableListOf("ab", "cde", "x")
|
||||
list.replaceAll { it.length.toString() }
|
||||
|
||||
val expected = listOf("2", "3", "1")
|
||||
assertEquals(expected, list)
|
||||
|
||||
list.replaceAll(UnaryOperator.identity())
|
||||
assertEquals(expected, list)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package kotlin.jdk8.collections.test
|
||||
|
||||
import org.junit.Test
|
||||
import java.util.function.BiFunction
|
||||
import kotlin.test.*
|
||||
import kotlin.jdk8.collections.*
|
||||
|
||||
class MapTest {
|
||||
|
||||
@Test fun getOrDefault() {
|
||||
val map = mapOf("x" to 1, "z" to null)
|
||||
assertEquals(1, map.getOrDefault("x", 0))
|
||||
assertEquals(0, map.getOrDefault("y", 0))
|
||||
assertEquals(null, map.getOrDefault("z", 0))
|
||||
assertEquals(null, map.getOrDefault("y" as CharSequence, null))
|
||||
|
||||
val nonNullMap = mapOf("x" to 1)
|
||||
assertEquals(null, nonNullMap.getOrDefault("y" as CharSequence, null)) // should pass
|
||||
assertEquals("none", nonNullMap.getOrDefault("y" as CharSequence, "none")) // should not compile
|
||||
}
|
||||
|
||||
@Test fun forEach() {
|
||||
val map = mapOf("k" to "v")
|
||||
map.forEach { k, v ->
|
||||
assertEquals("k", k)
|
||||
assertEquals("v", v)
|
||||
}
|
||||
map.forEach {
|
||||
assertEquals("k", it.key)
|
||||
assertEquals("v", it.value)
|
||||
}
|
||||
}
|
||||
|
||||
@Test fun replaceAll() {
|
||||
val map: MutableMap<String, CharSequence> = mutableMapOf("a" to "b", "c" to "d")
|
||||
|
||||
map.replaceAll { k, v -> k + v }
|
||||
assertEquals(mapOf<String, CharSequence>("a" to "ab", "c" to "cd"), map)
|
||||
|
||||
val operator = BiFunction<Any, Any, String> { k, v -> k.toString() + v.toString() }
|
||||
map.replaceAll(operator)
|
||||
assertEquals(mapOf<String, CharSequence>("a" to "aab", "c" to "ccd"), map)
|
||||
}
|
||||
|
||||
@Test fun putIfAbsent() {
|
||||
val map = mutableMapOf(1 to "a")
|
||||
|
||||
assertEquals("a", map.putIfAbsent(1, "b"))
|
||||
assertEquals("a", map[1])
|
||||
|
||||
assertEquals(null, map.putIfAbsent(2, "b"))
|
||||
assertEquals("b", map[2])
|
||||
}
|
||||
|
||||
|
||||
@Test fun removeKeyValue() {
|
||||
val map = mutableMapOf(1 to "a")
|
||||
|
||||
assertEquals(false, map.remove(1 as Number, null as Any?)) // requires import
|
||||
assertEquals(true, map.remove(1, "a"))
|
||||
}
|
||||
|
||||
@Test fun replace() {
|
||||
val map = mutableMapOf(1 to "a", 2 to null)
|
||||
assertTrue(map.replace(2, null, "x"))
|
||||
assertEquals("x", map[2])
|
||||
|
||||
assertFalse(map.replace(2, null, "x"))
|
||||
|
||||
assertEquals("a", map.replace(1, "b"))
|
||||
assertEquals(null, map.replace(3, "c"))
|
||||
|
||||
}
|
||||
|
||||
@Test fun computeIfAbsent() {
|
||||
val map = mutableMapOf(2 to "x")
|
||||
assertEquals("x", map.computeIfAbsent(2) { it.toString() })
|
||||
assertEquals("3", map.computeIfAbsent(3) { it.toString() })
|
||||
// prohibited: map.computeIfAbsent(0) { null }
|
||||
|
||||
val map2 = mutableMapOf(2 to "x", 3 to null)
|
||||
assertEquals("x", map2.computeIfAbsent(2) { it.toString() })
|
||||
assertEquals("3", map2.computeIfAbsent(3) { it.toString() })
|
||||
assertEquals(null, map2.computeIfAbsent(0) { null })
|
||||
assertFalse(0 in map2)
|
||||
}
|
||||
|
||||
@Test fun computeIfPresent() {
|
||||
val map = mutableMapOf(2 to "x")
|
||||
assertEquals("2x", map.computeIfPresent(2) { k, v -> k.toString() + v })
|
||||
assertEquals(null, map.computeIfPresent(3) { k, v -> k.toString() + v })
|
||||
assertEquals(null, map.computeIfPresent(2) { _, _ -> null })
|
||||
assertFalse(2 in map)
|
||||
|
||||
val map2 = mutableMapOf<Int, String?>(2 to "x")
|
||||
assertEquals("2x", map2.computeIfPresent(2) { k, v -> k.toString() + v })
|
||||
assertEquals(null, map2.computeIfPresent(3) { k, v -> k.toString() + v })
|
||||
assertEquals(null, map2.computeIfPresent(2) { _, _ -> null })
|
||||
assertFalse(2 in map2)
|
||||
}
|
||||
|
||||
@Test fun compute() {
|
||||
val map = mutableMapOf(2 to "x")
|
||||
assertEquals("2x", map.compute(2) { k, v -> k.toString() + v })
|
||||
assertEquals(null, map.compute(2) { _, _ -> null })
|
||||
assertFalse { 2 in map }
|
||||
assertEquals("1null", map.compute(1) { k, v -> k.toString() + v })
|
||||
}
|
||||
|
||||
@Test fun merge() {
|
||||
val map = mutableMapOf(2 to "x")
|
||||
assertEquals("y", map.merge(3, "y") { _, _ -> null })
|
||||
assertEquals(null, map.merge(3, "z") { old, new ->
|
||||
assertEquals("y", old)
|
||||
assertEquals("z", new)
|
||||
null
|
||||
})
|
||||
assertFalse(3 in map)
|
||||
|
||||
// fails due to KT-12144
|
||||
val map2 = mutableMapOf<Int, String?>(1 to null)
|
||||
// new value must be V&Any
|
||||
assertEquals("e", map2.merge(1, "e") { old, new -> (old.length + new.length).toString() ?: null })
|
||||
assertEquals("3", map2.merge(1, "fg") { old, new -> (old.length + new.length).toString() ?: null })
|
||||
assertEquals(null, map2.merge(1, "3") { _, _ -> null })
|
||||
assertFalse(1 in map)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package kotlin.jdk8.streams.test
|
||||
|
||||
import kotlin.streams.*
|
||||
import org.junit.Test
|
||||
import java.util.stream.*
|
||||
import kotlin.test.*
|
||||
|
||||
class StreamsTest {
|
||||
|
||||
@Test fun toList() {
|
||||
val data = arrayOf(1, 2L, 1.23, null)
|
||||
val streamBuilder = { Stream.of(*data) }
|
||||
|
||||
assertEquals(data.asList(), streamBuilder().toList())
|
||||
assertEquals(listOf(1), streamBuilder().filter { it is Int }.mapToInt { it as Int }.toList())
|
||||
assertEquals(listOf(2L), streamBuilder().filter { it is Long }.mapToLong { it as Long }.toList())
|
||||
assertEquals(listOf(1.23), streamBuilder().filter { it is Double }.mapToDouble { it as Double }.toList())
|
||||
}
|
||||
|
||||
|
||||
@Test fun asSequence() {
|
||||
val data = arrayOf(1, 2L, 1.23, null)
|
||||
|
||||
fun<T> assertSequenceContent(expected: List<T>, actual: Sequence<T>) {
|
||||
assertEquals(expected, actual.toList())
|
||||
assertFailsWith<IllegalStateException> ("Second iteration fails") { actual.toList() }
|
||||
|
||||
}
|
||||
|
||||
assertSequenceContent(data.asList(), Stream.of(*data).asSequence())
|
||||
assertSequenceContent(listOf(1, 2), IntStream.of(1, 2).asSequence())
|
||||
assertSequenceContent(listOf(1L, 2L), LongStream.of(1L, 2L).asSequence())
|
||||
assertSequenceContent(listOf(1.0, 2.0), DoubleStream.of(1.0, 2.0).asSequence())
|
||||
}
|
||||
|
||||
@Test fun asStream() {
|
||||
val sequence = generateSequence(0) { it -> it * it + 1 }
|
||||
val stream = sequence.asStream()
|
||||
val expected = Stream.iterate(0) { it -> it * it + 1 }
|
||||
|
||||
assertEquals(expected.limit(7).toList(), stream.limit(7).toList())
|
||||
}
|
||||
|
||||
@Test fun asParallelStream() {
|
||||
val sequence = generateSequence(0) { it + 2 } // even numbers
|
||||
val stream = sequence.asStream().parallel().map { it / 2 }
|
||||
|
||||
val n = 100000
|
||||
val expected = (0 until n).toList()
|
||||
|
||||
assertEquals(expected, stream.limit(n.toLong()).toList())
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package kotlin.text.test
|
||||
|
||||
import org.junit.Test
|
||||
import kotlin.test.*
|
||||
|
||||
class RegexTest {
|
||||
@Test fun namedGroups() {
|
||||
val input = "1a 2b 3c"
|
||||
val regex = "(?<num>\\d)(?<liter>\\w)".toRegex()
|
||||
|
||||
val matches = regex.findAll(input).toList()
|
||||
assertTrue(matches.all { it.groups.size == 3 })
|
||||
val m1 = matches[0]
|
||||
|
||||
assertEquals("1", m1.groups["num"]?.value)
|
||||
assertEquals(0..0, m1.groups["num"]?.range)
|
||||
assertEquals("a", m1.groups["liter"]?.value)
|
||||
assertEquals(1..1, m1.groups["liter"]?.range)
|
||||
|
||||
val m2 = matches[1]
|
||||
assertEquals("2", m2.groups["num"]?.value)
|
||||
assertEquals(3..3, m2.groups["num"]?.range)
|
||||
assertEquals("b", m2.groups["liter"]?.value)
|
||||
assertEquals(4..4, m2.groups["liter"]?.range)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user