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

Collection tests: format and fix usages of deprecated symbols.

Browse Source
This commit is contained in:
Ilya Ryzhenkov
2015-01-12 19:24:18 +03:00
parent 5a77a70710
commit 9b04f57a25
14 changed files with 198 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/stdlib/test/collections/ArraysJVMTest.kt
+4 -4
View File
@@ -40,14 +40,14 @@ class ArraysJVMTest {
expect(-4.toLong()) { longArray(1, 2, 3) reduce { a, b -> a - b } }
expect(-4.toFloat()) { floatArray(1.toFloat(), 2.toFloat(), 3.toFloat()) reduce { a, b -> a - b } }
expect(-4.0) { doubleArray(1.0, 2.0, 3.0) reduce { a, b -> a - b } }
expect('3') { charArray('1', '3', '2') reduce { a, b -> if(a > b) a else b } }
expect('3') { charArray('1', '3', '2') reduce { a, b -> if (a > b) a else b } }
expect(false) { booleanArray(true, true, false) reduce { a, b -> a && b } }
expect(true) { booleanArray(true, true) reduce { a, b -> a && b } }
expect(0.toByte()) { byteArray(3, 2, 1) reduce { a, b -> (a - b).toByte() } }
expect(0.toShort()) { shortArray(3, 2, 1) reduce { a, b -> (a - b).toShort() } }
failsWith (javaClass<UnsupportedOperationException>()) {
intArray().reduce { a, b -> a + b}
intArray().reduce { a, b -> a + b }
}
}
@@ -56,14 +56,14 @@ class ArraysJVMTest {
expect(2.toLong()) { longArray(1, 2, 3) reduceRight { a, b -> a - b } }
expect(2.toFloat()) { floatArray(1.toFloat(), 2.toFloat(), 3.toFloat()) reduceRight { a, b -> a - b } }
expect(2.0) { doubleArray(1.0, 2.0, 3.0) reduceRight { a, b -> a - b } }
expect('3') { charArray('1', '3', '2') reduceRight { a, b -> if(a > b) a else b } }
expect('3') { charArray('1', '3', '2') reduceRight { a, b -> if (a > b) a else b } }
expect(false) { booleanArray(true, true, false) reduceRight { a, b -> a && b } }
expect(true) { booleanArray(true, true) reduceRight { a, b -> a && b } }
expect(2.toByte()) { byteArray(1, 2, 3) reduceRight { a, b -> (a - b).toByte() } }
expect(2.toShort()) { shortArray(1, 2, 3) reduceRight { a, b -> (a - b).toShort() } }
failsWith (javaClass<UnsupportedOperationException>()) {
intArray().reduceRight { a, b -> a + b}
intArray().reduceRight { a, b -> a + b }
}
}
libraries/stdlib/test/collections/ArraysTest.kt
+16 -16
View File
@@ -3,7 +3,7 @@ package test.collections
import kotlin.test.*
import org.junit.Test as test
fun <T> checkContent(iter : Iterator<T>, length : Int, value : (Int) -> T) {
fun <T> checkContent(iter: Iterator<T>, length: Int, value: (Int) -> T) {
var idx = 0
while (idx != length && iter.hasNext()) {
assertEquals(value(idx++), iter.next(), "Invalid element")
@@ -19,7 +19,7 @@ class ArraysTest {
val arr1 = IntArray(0)
assertEquals(-1, arr1.lastIndex)
val arr2 = Array<String>(0, {"$it"})
val arr2 = Array<String>(0, { "$it" })
assertEquals(-1, arr2.lastIndex)
}
@@ -28,7 +28,7 @@ class ArraysTest {
assertEquals(4, arr1.lastIndex)
assertEquals(4, arr1[arr1.lastIndex])
val arr2 = Array<String>(5, {"$it"})
val arr2 = Array<String>(5, { "$it" })
assertEquals(4, arr2.lastIndex)
assertEquals("4", arr2[arr2.lastIndex])
}
@@ -124,7 +124,7 @@ class ArraysTest {
expect(1, { array(1).minBy { it } })
expect(3, { array(2, 3).minBy { -it } })
expect('a', { array('a', 'b').minBy { "x$it" } })
expect("b", { array("b", "abc").minBy { it.length } })
expect("b", { array("b", "abc").minBy { it.length() } })
}
test fun maxBy() {
@@ -132,7 +132,7 @@ class ArraysTest {
expect(1, { array(1).maxBy { it } })
expect(2, { array(2, 3).maxBy { -it } })
expect('b', { array('a', 'b').maxBy { "x$it" } })
expect("abc", { array("b", "abc").maxBy { it.length } })
expect("abc", { array("b", "abc").maxBy { it.length() } })
}
test fun minByEvaluateOnce() {
@@ -162,33 +162,33 @@ class ArraysTest {
expect(0) { array("cat", "dog", "bird").indexOf("cat") }
expect(1) { array("cat", "dog", "bird").indexOf("dog") }
expect(2) { array("cat", "dog", "bird").indexOf("bird") }
expect(0) { array(null, "dog", null).indexOf(null)}
expect(0) { array(null, "dog", null).indexOf(null) }
}
test fun plus() {
assertEquals(listOf("1","2","3","4"), array("1", "2") + array("3", "4"))
assertEquals(listOf("1","2","3","4"), listOf("1", "2") + array("3", "4"))
assertEquals(listOf("1", "2", "3", "4"), array("1", "2") + array("3", "4"))
assertEquals(listOf("1", "2", "3", "4"), listOf("1", "2") + array("3", "4"))
}
test fun plusVararg() {
fun onePlus(vararg a: String) = array("1") + a
assertEquals(listOf("1","2"), onePlus("2"))
assertEquals(listOf("1", "2"), onePlus("2"))
}
test fun first() {
expect(1) { array(1,2,3).first() }
expect(2) { array(1,2,3).first { it % 2 == 0 } }
expect(1) { array(1, 2, 3).first() }
expect(2) { array(1, 2, 3).first { it % 2 == 0 } }
}
test fun last() {
expect(3) { array(1,2,3).last() }
expect(2) { array(1,2,3).last { it % 2 == 0 } }
expect(3) { array(1, 2, 3).last() }
expect(2) { array(1, 2, 3).last { it % 2 == 0 } }
}
test fun contains() {
assertTrue(array("1","2","3","4").contains("2"))
assertTrue("3" in array("1","2","3","4"))
assertTrue("0" !in array("1","2","3","4"))
assertTrue(array("1", "2", "3", "4").contains("2"))
assertTrue("3" in array("1", "2", "3", "4"))
assertTrue("0" !in array("1", "2", "3", "4"))
}
test fun slice() {
libraries/stdlib/test/collections/CollectionJVMTest.kt
+34 -34
View File
@@ -9,7 +9,7 @@ import org.junit.Test as test
class CollectionJVMTest {
test fun flatMap() {
val data = arrayListOf("", "foo", "bar", "x", "")
val data = listOf("", "foo", "bar", "x", "")
val characters = data.flatMap { it.toCharList() }
println("Got list of characters ${characters}")
assertEquals(7, characters.size())
@@ -19,7 +19,7 @@ class CollectionJVMTest {
test fun filterIntoLinkedList() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
val foo = data.filterTo(linkedListOf<String>()) { it.startsWith("f") }
assertTrue {
@@ -33,8 +33,8 @@ class CollectionJVMTest {
}
}
test fun filterNotIntolinkedListOf() {
val data = arrayListOf("foo", "bar")
test fun filterNotIntoLinkedListOf() {
val data = listOf("foo", "bar")
val foo = data.filterNotTo(linkedListOf<String>()) { it.startsWith("f") }
assertTrue {
@@ -49,7 +49,7 @@ class CollectionJVMTest {
}
test fun filterNotNullIntoLinkedListOf() {
val data = arrayListOf(null, "foo", null, "bar")
val data = listOf(null, "foo", null, "bar")
val foo = data.filterNotNullTo(linkedListOf<String>())
assertEquals(2, foo.size())
@@ -61,8 +61,8 @@ class CollectionJVMTest {
}
test fun filterIntoSortedSet() {
val data = arrayListOf("foo", "bar")
val sorted = data.filterTo(sortedSetOf<String>()) { it.length == 3 }
val data = listOf("foo", "bar")
val sorted = data.filterTo(sortedSetOf<String>()) { it.length() == 3 }
assertEquals(2, sorted.size())
assertEquals(sortedSetOf("bar", "foo"), sorted)
assertTrue {
@@ -71,13 +71,13 @@ class CollectionJVMTest {
}
test fun first() {
assertEquals(19, TreeSet(arrayListOf(90, 47, 19)).first())
assertEquals(19, TreeSet(listOf(90, 47, 19)).first())
}
test fun last() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
assertEquals("bar", data.last())
assertEquals(25, arrayListOf(15, 19, 20, 25).last())
assertEquals(25, listOf(15, 19, 20, 25).last())
assertEquals('a', linkedListOf('a').last())
}
@@ -90,8 +90,8 @@ class CollectionJVMTest {
}
test fun toArray() {
val data = arrayListOf("foo", "bar")
val arr = data.toArray()
val data = listOf("foo", "bar")
val arr = data.copyToArray()
println("Got array ${arr}")
assertEquals(2, arr.size())
todo {
@@ -106,40 +106,40 @@ class CollectionJVMTest {
}
test fun filterIsInstanceList() {
val src: List<Any> = listOf(1,2,3.toDouble(), "abc", "cde")
val values: List<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde")
val ints: List<Int> = src.filterIsInstance<Int>()
assertEquals(arrayListOf(1,2), ints)
val intValues: List<Int> = values.filterIsInstance<Int>()
assertEquals(listOf(1, 2), intValues)
val doubles: List<Double> = src.filterIsInstance<Double>()
assertEquals(arrayListOf(3.0), doubles)
val doubleValues: List<Double> = values.filterIsInstance<Double>()
assertEquals(listOf(3.0), doubleValues)
val strings: List<String> = src.filterIsInstance<String>()
assertEquals(arrayListOf("abc", "cde"), strings)
val stringValues: List<String> = values.filterIsInstance<String>()
assertEquals(listOf("abc", "cde"), stringValues)
val anys: List<Any> = src.filterIsInstance<Any>()
assertEquals(src.toList(), anys)
val anyValues: List<Any> = values.filterIsInstance<Any>()
assertEquals(values.toList(), anyValues)
val chars: List<Char> = src.filterIsInstance<Char>()
assertEquals(0, chars.size())
val charValues: List<Char> = values.filterIsInstance<Char>()
assertEquals(0, charValues.size())
}
test fun filterIsInstanceArray() {
val src: Array<Any> = array(1,2,3.toDouble(), "abc", "cde")
val src: Array<Any> = array(1, 2, 3.toDouble(), "abc", "cde")
val ints: List<Int> = src.filterIsInstance<Int>()
assertEquals(arrayListOf(1,2), ints)
val intValues: List<Int> = src.filterIsInstance<Int>()
assertEquals(listOf(1, 2), intValues)
val doubles: List<Double> = src.filterIsInstance<Double>()
assertEquals(arrayListOf(3.0), doubles)
val doubleValues: List<Double> = src.filterIsInstance<Double>()
assertEquals(listOf(3.0), doubleValues)
val strings: List<String> = src.filterIsInstance<String>()
assertEquals(arrayListOf("abc", "cde"), strings)
val stringValues: List<String> = src.filterIsInstance<String>()
assertEquals(listOf("abc", "cde"), stringValues)
val anys: List<Any> = src.filterIsInstance<Any>()
assertEquals(src.toList(), anys)
val anyValues: List<Any> = src.filterIsInstance<Any>()
assertEquals(src.toList(), anyValues)
val chars: List<Char> = src.filterIsInstance<Char>()
assertEquals(0, chars.size())
val charValues: List<Char> = src.filterIsInstance<Char>()
assertEquals(0, charValues.size())
}
}
libraries/stdlib/test/collections/CollectionTest.kt
+92 -92
View File
@@ -7,28 +7,28 @@ import org.junit.Test as test
class CollectionTest {
test fun joinTo() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
val buffer = StringBuilder()
data.joinTo(buffer, "-", "{", "}")
assertEquals("{foo-bar}", buffer.toString())
}
test fun join() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
val text = data.join("-", "<", ">")
assertEquals("<foo-bar>", text)
val big = arrayListOf("a", "b", "c", "d", "e", "f")
val big = listOf("a", "b", "c", "d", "e", "f")
val text2 = big.join(limit = 3, truncated = "*")
assertEquals("a, b, c, *", text2)
}
test fun filterNotNull() {
val data = arrayListOf(null, "foo", null, "bar")
val data = listOf(null, "foo", null, "bar")
val foo = data.filterNotNull()
assertEquals(2, foo.size())
assertEquals(arrayListOf("foo", "bar"), foo)
assertEquals(listOf("foo", "bar"), foo)
assertTrue {
foo is List<String>
@@ -36,10 +36,10 @@ class CollectionTest {
}
test fun mapNotNull() {
val data = arrayListOf(null, "foo", null, "bar")
val foo = data.mapNotNull { it.length }
val data = listOf(null, "foo", null, "bar")
val foo = data.mapNotNull { it.length() }
assertEquals(2, foo.size())
assertEquals(arrayListOf(3, 3), foo)
assertEquals(listOf(3, 3), foo)
assertTrue {
foo is List<Int>
@@ -47,7 +47,7 @@ class CollectionTest {
}
test fun filterIntoSet() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
val foo = data.filterTo(hashSetOf<String>()) { it.startsWith("f") }
assertTrue {
@@ -64,7 +64,7 @@ class CollectionTest {
test fun fold() {
// lets calculate the sum of some numbers
expect(10) {
val numbers = arrayListOf(1, 2, 3, 4)
val numbers = listOf(1, 2, 3, 4)
numbers.fold(0) { a, b -> a + b }
}
@@ -75,47 +75,47 @@ class CollectionTest {
// lets concatenate some strings
expect("1234") {
val numbers = arrayListOf(1, 2, 3, 4)
val numbers = listOf(1, 2, 3, 4)
numbers.map { it.toString() }.fold("") { a, b -> a + b }
}
}
test fun foldWithDifferentTypes() {
expect(7) {
val numbers = arrayListOf("a", "ab", "abc")
val numbers = listOf("a", "ab", "abc")
numbers.fold(1) { a, b -> a + b.length() }
}
expect("1234") {
val numbers = arrayListOf(1, 2, 3, 4)
val numbers = listOf(1, 2, 3, 4)
numbers.fold("") { a, b -> a + b }
}
}
test fun foldWithNonCommutativeOperation() {
expect(1) {
val numbers = arrayListOf(1, 2, 3)
val numbers = listOf(1, 2, 3)
numbers.fold(7) { a, b -> a - b }
}
}
test fun foldRight() {
expect("1234") {
val numbers = arrayListOf(1, 2, 3, 4)
val numbers = listOf(1, 2, 3, 4)
numbers.map { it.toString() }.foldRight("") { a, b -> a + b }
}
}
test fun foldRightWithDifferentTypes() {
expect("1234") {
val numbers = arrayListOf(1, 2, 3, 4)
val numbers = listOf(1, 2, 3, 4)
numbers.foldRight("") { a, b -> "" + a + b }
}
}
test fun foldRightWithNonCommutativeOperation() {
expect(-5) {
val numbers = arrayListOf(1, 2, 3)
val numbers = listOf(1, 2, 3)
numbers.foldRight(7) { a, b -> a - b }
}
}
@@ -135,21 +135,21 @@ class CollectionTest {
}
test fun partition() {
val data = arrayListOf("foo", "bar", "something", "xyz")
val data = listOf("foo", "bar", "something", "xyz")
val pair = data.partition { it.length() == 3 }
assertEquals(arrayListOf("foo", "bar", "xyz"), pair.first, "pair.first")
assertEquals(arrayListOf("something"), pair.second, "pair.second")
assertEquals(listOf("foo", "bar", "xyz"), pair.first, "pair.first")
assertEquals(listOf("something"), pair.second, "pair.second")
}
test fun reduce() {
expect("1234") {
val list = arrayListOf("1", "2", "3", "4")
val list = listOf("1", "2", "3", "4")
list.reduce { a, b -> a + b }
}
// TODO replace with more accurate version when KT-5987 will be fixed
// failsWith(javaClass<UnsupportedOperationException>()) {
// TODO replace with more accurate version when KT-5987 will be fixed
// failsWith(javaClass<UnsupportedOperationException>()) {
fails {
arrayListOf<Int>().reduce { a, b -> a + b }
}
@@ -157,20 +157,20 @@ class CollectionTest {
test fun reduceRight() {
expect("1234") {
val list = arrayListOf("1", "2", "3", "4")
val list = listOf("1", "2", "3", "4")
list.reduceRight { a, b -> a + b }
}
// TODO replace with more accurate version when KT-5987 will be fixed
// failsWith(javaClass<UnsupportedOperationException>()) {
// TODO replace with more accurate version when KT-5987 will be fixed
// failsWith(javaClass<UnsupportedOperationException>()) {
fails {
arrayListOf<Int>().reduceRight { a, b -> a + b }
}
}
test fun groupBy() {
val words = arrayListOf("a", "abc", "ab", "def", "abcd")
val byLength = words.groupBy { it.length }
val words = listOf("a", "abc", "ab", "def", "abcd")
val byLength = words.groupBy { it.length() }
assertEquals(4, byLength.size())
// verify that order of keys is preserved
@@ -197,45 +197,45 @@ class CollectionTest {
}
test fun plus() {
val list = arrayListOf("foo", "bar")
val list = listOf("foo", "bar")
val list2 = list + "cheese"
assertEquals(arrayListOf("foo", "bar"), list)
assertEquals(arrayListOf("foo", "bar", "cheese"), list2)
assertEquals(listOf("foo", "bar"), list)
assertEquals(listOf("foo", "bar", "cheese"), list2)
// lets use a mutable variable
var list3 = listOf("a", "b")
list3 += "c"
assertEquals(arrayListOf("a", "b", "c"), list3)
assertEquals(listOf("a", "b", "c"), list3)
}
test fun plusCollectionBug() {
val list = arrayListOf("foo", "bar") + arrayListOf("cheese", "wine")
assertEquals(arrayListOf("foo", "bar", "cheese", "wine"), list)
val list = listOf("foo", "bar") + listOf("cheese", "wine")
assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
}
test fun plusCollection() {
val a = arrayListOf("foo", "bar")
val b = arrayListOf("cheese", "wine")
val a = listOf("foo", "bar")
val b = listOf("cheese", "wine")
val list = a + b
assertEquals(arrayListOf("foo", "bar", "cheese", "wine"), list)
assertEquals(listOf("foo", "bar", "cheese", "wine"), list)
// lets use a mutable variable
var ml: List<String> = a
ml += "beer"
ml += b
ml += "z"
assertEquals(arrayListOf("foo", "bar", "beer", "cheese", "wine", "z"), ml)
assertEquals(listOf("foo", "bar", "beer", "cheese", "wine", "z"), ml)
}
test fun requireNoNulls() {
val data = arrayListOf<String?>("foo", "bar")
val notNull = data.requireNoNulls()
assertEquals(arrayListOf("foo", "bar"), notNull)
assertEquals(listOf("foo", "bar"), notNull)
val hasNulls = arrayListOf("foo", null, "bar")
val hasNulls = listOf("foo", null, "bar")
// TODO replace with more accurate version when KT-5987 will be fixed
// failsWith(javaClass<IllegalArgumentException>()) {
// TODO replace with more accurate version when KT-5987 will be fixed
// failsWith(javaClass<IllegalArgumentException>()) {
fails {
// should throw an exception as we have a null
hasNulls.requireNoNulls()
@@ -243,49 +243,49 @@ class CollectionTest {
}
test fun reverse() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
val rev = data.reverse()
assertEquals(arrayListOf("bar", "foo"), rev)
assertEquals(listOf("bar", "foo"), rev)
}
test fun reverseFunctionShouldReturnReversedCopyForList() {
val list: List<Int> = arrayListOf(2, 3, 1)
expect(arrayListOf(1, 3, 2)) { list.reverse() }
expect(arrayListOf(2, 3, 1)) { list }
val list: List<Int> = listOf(2, 3, 1)
expect(listOf(1, 3, 2)) { list.reverse() }
expect(listOf(2, 3, 1)) { list }
}
test fun reverseFunctionShouldReturnReversedCopyForIterable() {
val iterable: Iterable<Int> = arrayListOf(2, 3, 1)
expect(arrayListOf(1, 3, 2)) { iterable.reverse() }
expect(arrayListOf(2, 3, 1)) { iterable }
val iterable: Iterable<Int> = listOf(2, 3, 1)
expect(listOf(1, 3, 2)) { iterable.reverse() }
expect(listOf(2, 3, 1)) { iterable }
}
test fun drop() {
val coll = arrayListOf("foo", "bar", "abc")
assertEquals(arrayListOf("bar", "abc"), coll.drop(1))
assertEquals(arrayListOf("abc"), coll.drop(2))
val coll = listOf("foo", "bar", "abc")
assertEquals(listOf("bar", "abc"), coll.drop(1))
assertEquals(listOf("abc"), coll.drop(2))
}
test fun dropWhile() {
val coll = arrayListOf("foo", "bar", "abc")
assertEquals(arrayListOf("bar", "abc"), coll.dropWhile { it.startsWith("f") })
val coll = listOf("foo", "bar", "abc")
assertEquals(listOf("bar", "abc"), coll.dropWhile { it.startsWith("f") })
}
test fun take() {
val coll = arrayListOf("foo", "bar", "abc")
assertEquals(arrayListOf("foo"), coll.take(1))
assertEquals(arrayListOf("foo", "bar"), coll.take(2))
val coll = listOf("foo", "bar", "abc")
assertEquals(listOf("foo"), coll.take(1))
assertEquals(listOf("foo", "bar"), coll.take(2))
}
test fun takeWhile() {
val coll = arrayListOf("foo", "bar", "abc")
assertEquals(arrayListOf("foo"), coll.takeWhile { it.startsWith("f") })
assertEquals(arrayListOf("foo", "bar", "abc"), coll.takeWhile { it.length() == 3 })
val coll = listOf("foo", "bar", "abc")
assertEquals(listOf("foo"), coll.takeWhile { it.startsWith("f") })
assertEquals(listOf("foo", "bar", "abc"), coll.takeWhile { it.length() == 3 })
}
test fun copyToArray() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
val arr = data.copyToArray()
println("Got array ${arr}")
assertEquals(2, arr.size())
@@ -297,25 +297,25 @@ class CollectionTest {
}
test fun count() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
assertEquals(2, data.count())
assertEquals(3, hashSetOf(12, 14, 15).count())
assertEquals(0, ArrayList<Double>().count())
}
test fun first() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
assertEquals("foo", data.first())
assertEquals(15, arrayListOf(15, 19, 20, 25).first())
assertEquals('a', arrayListOf('a').first())
assertEquals(15, listOf(15, 19, 20, 25).first())
assertEquals('a', listOf('a').first())
fails { arrayListOf<Int>().first() }
}
test fun last() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
assertEquals("bar", data.last())
assertEquals(25, arrayListOf(15, 19, 20, 25).last())
assertEquals('a', arrayListOf('a').last())
assertEquals(25, listOf(15, 19, 20, 25).last())
assertEquals('a', listOf('a').last())
fails { arrayListOf<Int>().last() }
}
@@ -339,11 +339,11 @@ class CollectionTest {
}
list.add("works")
assertEquals(arrayListOf("new", "thing", "works"), list)
assertEquals(listOf("new", "thing", "works"), list)
}
test fun indices() {
val data = arrayListOf("foo", "bar")
val data = listOf("foo", "bar")
val indices = data.indices
assertEquals(0, indices.start)
assertEquals(1, indices.end)
@@ -352,21 +352,21 @@ class CollectionTest {
test fun contains() {
assertFalse(hashSetOf<Int>().contains(12))
assertTrue(arrayListOf(15, 19, 20).contains(15))
assertTrue(listOf(15, 19, 20).contains(15))
assertTrue(IterableWrapper(hashSetOf(45, 14, 13)).contains(14))
}
test fun sortForMutableIterable() {
val list: MutableIterable<Int> = arrayListOf(2, 3, 1)
expect(arrayListOf(1, 2, 3)) { list.sort() }
expect(arrayListOf(2, 3, 1)) { list }
expect(listOf(1, 2, 3)) { list.sort() }
expect(listOf(2, 3, 1)) { list }
}
test fun sortForIterable() {
val list: Iterable<Int> = listOf(2, 3, 1)
expect(arrayListOf(1, 2, 3)) { list.sort() }
expect(arrayListOf(2, 3, 1)) { list }
expect(listOf(1, 2, 3)) { list.sort() }
expect(listOf(2, 3, 1)) { list }
}
test fun min() {
@@ -396,7 +396,7 @@ class CollectionTest {
expect(1, { listOf(1).minBy { it } })
expect(3, { listOf(2, 3).minBy { -it } })
expect('a', { listOf('a', 'b').minBy { "x$it" } })
expect("b", { listOf("b", "abc").minBy { it.length } })
expect("b", { listOf("b", "abc").minBy { it.length() } })
expect(null, { listOf<Int>().stream().minBy { it } })
expect(3, { listOf(2, 3).stream().minBy { -it } })
}
@@ -406,7 +406,7 @@ class CollectionTest {
expect(1, { listOf(1).maxBy { it } })
expect(2, { listOf(2, 3).maxBy { -it } })
expect('b', { listOf('a', 'b').maxBy { "x$it" } })
expect("abc", { listOf("b", "abc").maxBy { it.length } })
expect("abc", { listOf("b", "abc").maxBy { it.length() } })
expect(null, { listOf<Int>().stream().maxBy { it } })
expect(2, { listOf(2, 3).stream().maxBy { -it } })
}
@@ -431,8 +431,8 @@ class CollectionTest {
test fun sum() {
expect(0) { arrayListOf<Int>().sum() }
expect(14) { arrayListOf(2, 3, 9).sum() }
expect(3.0) { arrayListOf(1.0, 2.0).sum() }
expect(14) { listOf(2, 3, 9).sum() }
expect(3.0) { listOf(1.0, 2.0).sum() }
expect(3000000000000) { arrayListOf<Long>(1000000000000, 2000000000000).sum() }
expect(3.0.toFloat()) { arrayListOf<Float>(1.0.toFloat(), 2.0.toFloat()).sum() }
expect(3.0.toFloat()) { streamOf<Float>(1.0.toFloat(), 2.0.toFloat()).sum() }
@@ -450,27 +450,27 @@ class CollectionTest {
}
test fun sortBy() {
expect(arrayListOf("two" to 2, "three" to 3)) {
arrayListOf("three" to 3, "two" to 2).sortBy { it.second }
expect(listOf("two" to 2, "three" to 3)) {
listOf("three" to 3, "two" to 2).sortBy { it.second }
}
expect(arrayListOf("three" to 3, "two" to 2)) {
arrayListOf("three" to 3, "two" to 2).sortBy { it.first }
expect(listOf("three" to 3, "two" to 2)) {
listOf("three" to 3, "two" to 2).sortBy { it.first }
}
expect(arrayListOf("two" to 2, "three" to 3)) {
arrayListOf("three" to 3, "two" to 2).sortBy { it.first.length }
expect(listOf("two" to 2, "three" to 3)) {
listOf("three" to 3, "two" to 2).sortBy { it.first.length() }
}
}
test fun sortFunctionShouldReturnSortedCopyForList() {
val list: List<Int> = arrayListOf(2, 3, 1)
expect(arrayListOf(1, 2, 3)) { list.sort() }
expect(arrayListOf(2, 3, 1)) { list }
val list: List<Int> = listOf(2, 3, 1)
expect(listOf(1, 2, 3)) { list.sort() }
expect(listOf(2, 3, 1)) { list }
}
test fun sortFunctionShouldReturnSortedCopyForIterable() {
val list: Iterable<Int> = arrayListOf(2, 3, 1)
expect(arrayListOf(1, 2, 3)) { list.sort() }
expect(arrayListOf(2, 3, 1)) { list }
val list: Iterable<Int> = listOf(2, 3, 1)
expect(listOf(1, 2, 3)) { list.sort() }
expect(listOf(2, 3, 1)) { list }
}
test fun decomposeFirst() {
libraries/stdlib/test/collections/IterableJVMTests.kt
-2
View File
@@ -1,7 +1,5 @@
package test.collections
import org.junit.Test
import kotlin.test.*
import java.util.*
class LinkedSetTest : OrderedIterableTests<Set<String>>(setOf("foo", "bar"), setOf<String>())
libraries/stdlib/test/collections/IterableTests.kt
+14 -14
View File
@@ -4,7 +4,7 @@ import org.junit.Test
import kotlin.test.*
import java.util.*
fun <T> iterableOf(vararg items : T) : Iterable<T> = IterableWrapper(items.toList())
fun <T> iterableOf(vararg items: T): Iterable<T> = IterableWrapper(items.toList())
class IterableWrapper<T>(collection: Iterable<T>) : Iterable<T> {
private val collection = collection
@@ -89,7 +89,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
}
Test fun all() {
expect(true) { data.all { it.length == 3 } }
expect(true) { data.all { it.length() == 3 } }
expect(false) { data.all { it.startsWith("b") } }
expect(true) { empty.all { it.startsWith("b") } }
}
@@ -97,7 +97,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
Test fun none() {
expect(false) { data.none() }
expect(true) { empty.none() }
expect(false) { data.none { it.length == 3 } }
expect(false) { data.none { it.length() == 3 } }
expect(false) { data.none { it.startsWith("b") } }
expect(true) { data.none { it.startsWith("x") } }
expect(true) { empty.none { it.startsWith("b") } }
@@ -121,7 +121,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
Test fun forEach() {
var count = 0
data.forEach { count += it.length }
data.forEach { count += it.length() }
assertEquals(6, count)
}
@@ -138,7 +138,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
expect("foo") { data.single { it.startsWith("f") } }
expect("bar") { data.single { it.startsWith("b") } }
fails {
data.single { it.length == 3 }
data.single { it.length() == 3 }
}
}
@@ -149,32 +149,32 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
expect("foo") { data.singleOrNull { it.startsWith("f") } }
expect("bar") { data.singleOrNull { it.startsWith("b") } }
expect(null) {
data.singleOrNull { it.length == 3 }
data.singleOrNull { it.length() == 3 }
}
}
Test
fun map() {
val lengths = data.map { it.length }
val lengths = data.map { it.length() }
assertTrue {
lengths.all { it == 3 }
}
assertEquals(2, lengths.size())
assertEquals(arrayListOf(3, 3), lengths)
assertEquals(listOf(3, 3), lengths)
}
Test
fun mapIndexed() {
val shortened = data.mapIndexed { (index, value)-> value.substring(0..index) }
val shortened = data.mapIndexed {(index, value) -> value.substring(0..index) }
assertEquals(2, shortened.size())
assertEquals(arrayListOf("f", "ba"), shortened)
assertEquals(listOf("f", "ba"), shortened)
}
Test
fun withIndex() {
val indexed = data.withIndex().map { it.value.substring(0..it.index) }
assertEquals(2, indexed.size())
assertEquals(arrayListOf("f", "ba"), indexed)
assertEquals(listOf("f", "ba"), indexed)
}
Test
@@ -204,7 +204,7 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
Test
fun withIndices() {
var index = 0
for ((i, d) in data.withIndices()) {
for ((i, d) in data.withIndex()) {
assertEquals(i, index)
assertEquals(d, data.elementAt(index))
index++
@@ -214,12 +214,12 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
Test
fun fold() {
expect(231) { data.fold(1, {a, b -> a + if (b == "foo") 200 else 30 }) }
expect(231) { data.fold(1, { a, b -> a + if (b == "foo") 200 else 30 }) }
}
Test
fun reduce() {
val reduced = data.reduce {a, b -> a + b }
val reduced = data.reduce { a, b -> a + b }
assertEquals(6, reduced.length())
assertTrue(reduced == "foobar" || reduced == "barfoo")
}
libraries/stdlib/test/collections/IteratorsJVMTest.kt
+2 -2
View File
@@ -8,11 +8,11 @@ class IteratorsJVMTest {
test fun testEnumeration() {
val v = Vector<Int>()
for(i in 1..5)
for (i in 1..5)
v.add(i)
var sum = 0
for(k in v.elements())
for (k in v.elements())
sum += k
assertEquals(15, sum)
libraries/stdlib/test/collections/IteratorsTest.kt
+1 -1
View File
@@ -5,7 +5,7 @@ import org.junit.Test as test
class IteratorsTest {
test fun iterationOverIterator() {
val c = arrayListOf(0, 1, 2, 3, 4, 5)
val c = listOf(0, 1, 2, 3, 4, 5)
var s = ""
for (i in c.iterator()) {
s = s + i.toString()
libraries/stdlib/test/collections/ListSpecificTest.kt
+2 -3
View File
@@ -12,10 +12,9 @@ class ListSpecificTest {
}
Test fun tail() {
val data = arrayListOf("foo", "bar", "whatnot")
val data = listOf("foo", "bar", "whatnot")
val actual = data.drop(1)
val expected = arrayListOf("bar", "whatnot")
assertEquals(expected, actual)
assertEquals(listOf("bar", "whatnot"), actual)
}
Test fun slice() {
libraries/stdlib/test/collections/MapJVMTest.kt
+3 -3
View File
@@ -9,7 +9,7 @@ class MapJVMTest {
assertEquals(1, map["a"])
assertEquals(2, map["b"])
assertEquals(3, map["c"])
assertEquals(arrayListOf("a", "b", "c"), map.keySet().toList())
assertEquals(listOf("a", "b", "c"), map.keySet().toList())
}
test fun toSortedMap() {
@@ -18,13 +18,13 @@ class MapJVMTest {
assertEquals(1, sorted["a"])
assertEquals(2, sorted["b"])
assertEquals(3, sorted["c"])
assertEquals(arrayListOf("a", "b", "c"), sorted.keySet().toList())
assertEquals(listOf("a", "b", "c"), sorted.keySet().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(arrayListOf("c", "bc", "bd", "abc"), sorted.keySet().toList())
assertEquals(listOf("c", "bc", "bd", "abc"), sorted.keySet().toList())
assertEquals(1, sorted["abc"])
assertEquals(2, sorted["bc"])
assertEquals(3, sorted["c"])
libraries/stdlib/test/collections/MapTest.kt
+5 -5
View File
@@ -51,7 +51,7 @@ class MapTest {
assertEquals(map.size(), 1)
assertEquals("James", map["name"])
}
test fun iterate() {
val map = mapOf("beverage" to "beer", "location" to "Mells", "name" to "James")
val list = arrayListOf<String>()
@@ -98,7 +98,7 @@ class MapTest {
val m1 = mapOf("beverage" to "beer", "location" to "Mells")
val list = m1.map { it.value + " rocks" }
assertEquals(arrayListOf("beer rocks", "Mells rocks"), list)
assertEquals(listOf("beer rocks", "Mells rocks"), list)
}
test fun mapValues() {
@@ -132,7 +132,7 @@ class MapTest {
}
test fun createWithSelector() {
val map = listOf("a", "bb", "ccc").toMap { it.length }
val map = listOf("a", "bb", "ccc").toMap { it.length() }
assertEquals(3, map.size())
assertEquals("a", map.get(1))
assertEquals("bb", map.get(2))
@@ -140,7 +140,7 @@ class MapTest {
}
test fun createWithSelectorAndOverwrite() {
val map = listOf("aa", "bb", "ccc").toMap { it.length }
val map = listOf("aa", "bb", "ccc").toMap { it.length() }
assertEquals(2, map.size())
assertEquals("bb", map.get(2))
assertEquals("ccc", map.get(3))
@@ -158,7 +158,7 @@ class MapTest {
assertEquals(1, map["a"])
assertEquals(2, map["b"])
assertEquals(3, map["c"])
assertEquals(arrayListOf("c", "b", "a"), map.keySet().toList())
assertEquals(listOf("c", "b", "a"), map.keySet().toList())
}
test fun filter() {
libraries/stdlib/test/collections/MutableCollectionsTest.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.junit.Test as test
class MutableCollectionTest {
test fun fromIterable() {
val data: Iterable<String> = arrayListOf("foo", "bar")
val data: Iterable<String> = listOf("foo", "bar")
val collection = ArrayList<String>()
collection.addAll(data)
@@ -18,7 +18,7 @@ class MutableCollectionTest {
}
test fun fromStream() {
val list = arrayListOf("foo", "bar")
val list = listOf("foo", "bar")
val collection = ArrayList<String>()
collection.addAll(list.stream())
libraries/stdlib/test/collections/StreamJVMTest.kt
+11 -11
View File
@@ -6,21 +6,21 @@ import kotlin.test.assertEquals
class StreamJVMTest {
test fun filterIsInstance() {
val src: Stream<Any> = listOf(1,2,3.toDouble(), "abc", "cde").stream()
val src: Stream<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde").stream()
val ints: Stream<Int> = src.filterIsInstance<Int>()
assertEquals(arrayListOf(1,2), ints.toArrayList())
val intValues: Stream<Int> = src.filterIsInstance<Int>()
assertEquals(listOf(1, 2), intValues.toArrayList())
val doubles: Stream<Double> = src.filterIsInstance<Double>()
assertEquals(arrayListOf(3.0), doubles.toArrayList())
val doubleValues: Stream<Double> = src.filterIsInstance<Double>()
assertEquals(listOf(3.0), doubleValues.toArrayList())
val strings: Stream<String> = src.filterIsInstance<String>()
assertEquals(arrayListOf("abc", "cde"), strings.toArrayList())
val stringValues: Stream<String> = src.filterIsInstance<String>()
assertEquals(listOf("abc", "cde"), stringValues.toArrayList())
val anys: Stream<Any> = src.filterIsInstance<Any>()
assertEquals(src.toList(), anys.toArrayList())
val anyValues: Stream<Any> = src.filterIsInstance<Any>()
assertEquals(src.toList(), anyValues.toArrayList())
val chars: Stream<Char> = src.filterIsInstance<Char>()
assertEquals(0, chars.toArrayList().size())
val charValues: Stream<Char> = src.filterIsInstance<Char>()
assertEquals(0, charValues.toArrayList().size())
}
}
libraries/stdlib/test/collections/StreamTest.kt
+12 -12
View File
@@ -34,7 +34,7 @@ public class StreamTest {
test fun requireNoNulls() {
val stream = streamOf<String?>("foo", "bar")
val notNull = stream.requireNoNulls()
assertEquals(arrayListOf("foo", "bar"), notNull.toList())
assertEquals(listOf("foo", "bar"), notNull.toList())
val streamWithNulls = streamOf("foo", null, "bar")
val notNull2 = streamWithNulls.requireNoNulls() // shouldn't fail yet
@@ -47,19 +47,19 @@ public class StreamTest {
test fun filterNullable() {
val data = streamOf(null, "foo", null, "bar")
val filtered = data.filter { it == null || it == "foo" }
assertEquals(arrayListOf(null, "foo", null), filtered.toList())
assertEquals(listOf(null, "foo", null), filtered.toList())
}
test fun filterNotNull() {
val data = streamOf(null, "foo", null, "bar")
val filtered = data.filterNotNull()
assertEquals(arrayListOf("foo", "bar"), filtered.toList())
assertEquals(listOf("foo", "bar"), filtered.toList())
}
test fun mapNotNull() {
val data = streamOf(null, "foo", null, "bar")
val foo = data.mapNotNull { it.length }
assertEquals(arrayListOf(3, 3), foo.toList())
val foo = data.mapNotNull { it.length() }
assertEquals(listOf(3, 3), foo.toList())
assertTrue {
foo is Stream<Int>
@@ -67,20 +67,20 @@ public class StreamTest {
}
test fun filterAndTakeWhileExtractTheElementsWithinRange() {
assertEquals(arrayListOf(144, 233, 377, 610, 987), fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.toList())
assertEquals(listOf(144, 233, 377, 610, 987), fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.toList())
}
test fun foldReducesTheFirstNElements() {
val sum = {(a: Int, b: Int) -> a + b }
assertEquals(arrayListOf(13, 21, 34, 55, 89).fold(0, sum), fibonacci().filter { it > 10 }.take(5).fold(0, sum))
assertEquals(listOf(13, 21, 34, 55, 89).fold(0, sum), fibonacci().filter { it > 10 }.take(5).fold(0, sum))
}
test fun takeExtractsTheFirstNElements() {
assertEquals(arrayListOf(0, 1, 1, 2, 3, 5, 8, 13, 21, 34), fibonacci().take(10).toList())
assertEquals(listOf(0, 1, 1, 2, 3, 5, 8, 13, 21, 34), fibonacci().take(10).toList())
}
test fun mapAndTakeWhileExtractTheTransformedElements() {
assertEquals(arrayListOf(0, 3, 3, 6, 9, 15), fibonacci().map { it * 3 }.takeWhile {(i: Int) -> i < 20 }.toList())
assertEquals(listOf(0, 3, 3, 6, 9, 15), fibonacci().map { it * 3 }.takeWhile {(i: Int) -> i < 20 }.toList())
}
test fun joinConcatenatesTheFirstNElementsAboveAThreshold() {
@@ -162,7 +162,7 @@ public class StreamTest {
test fun streamFromFunctionWithInitialValue() {
val values = stream(3) { n -> if (n > 0) n - 1 else null }
assertEquals(arrayListOf(3, 2, 1, 0), values.toList())
assertEquals(listOf(3, 2, 1, 0), values.toList())
}
private fun <T, C : MutableCollection<in T>> Stream<T>.takeWhileTo(result: C, predicate: (T) -> Boolean): C {
@@ -177,7 +177,7 @@ public class StreamTest {
}
test fun flatMapAndTakeExtractTheTransformedElements() {
val expected = arrayListOf(
val expected = listOf(
'3', // fibonacci(4) = 3
'5', // fibonacci(5) = 5
'8', // fibonacci(6) = 8
@@ -185,7 +185,7 @@ public class StreamTest {
'2', '1', // fibonacci(8) = 21
'3', '4', // fibonacci(9) = 34
'5' // fibonacci(10) = 55
)
)
assertEquals(expected, fibonacci().drop(4).flatMap { it.toString().stream() }.take(10).toList())
}