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

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

Browse Source
This commit is contained in:
Ilya Gorbunov
2016-11-16 21:26:39 +03:00
parent 50cd620f92
commit 6a70761783
48 changed files with 749 additions and 751 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/stdlib/test/collections/SequenceTest.kt
+52 -53
View File
@@ -1,6 +1,5 @@
package test.collections
import org.junit.Test as test
import org.junit.Test
import kotlin.test.*
import kotlin.comparisons.*
@@ -13,20 +12,20 @@ fun fibonacci(): Sequence<Int> {
public class SequenceTest {
@test fun filterEmptySequence() {
@Test fun filterEmptySequence() {
for (sequence in listOf(emptySequence<String>(), sequenceOf<String>())) {
assertEquals(0, sequence.filter { false }.count())
assertEquals(0, sequence.filter { true }.count())
}
}
@test fun mapEmptySequence() {
@Test fun mapEmptySequence() {
for (sequence in listOf(emptySequence<String>(), sequenceOf<String>())) {
assertEquals(0, sequence.map { true }.count())
}
}
@test fun requireNoNulls() {
@Test fun requireNoNulls() {
val sequence = sequenceOf<String?>("foo", "bar")
val notNull = sequence.requireNoNulls()
assertEquals(listOf("foo", "bar"), notNull.toList())
@@ -39,37 +38,37 @@ public class SequenceTest {
}
}
@test fun filterIndexed() {
@Test fun filterIndexed() {
assertEquals(listOf(1, 2, 5, 13, 34), fibonacci().filterIndexed { index, value -> index % 2 == 1 }.take(5).toList())
}
@test fun filterNullable() {
@Test fun filterNullable() {
val data = sequenceOf(null, "foo", null, "bar")
val filtered = data.filter { it == null || it == "foo" }
assertEquals(listOf(null, "foo", null), filtered.toList())
}
@test fun filterNot() {
@Test fun filterNot() {
val data = sequenceOf(null, "foo", null, "bar")
val filtered = data.filterNot { it == null }
assertEquals(listOf("foo", "bar"), filtered.toList())
}
@test fun filterNotNull() {
@Test fun filterNotNull() {
val data = sequenceOf(null, "foo", null, "bar")
val filtered = data.filterNotNull()
assertEquals(listOf("foo", "bar"), filtered.toList())
}
@test fun mapIndexed() {
@Test fun mapIndexed() {
assertEquals(listOf(0, 1, 2, 6, 12), fibonacci().mapIndexed { index, value -> index * value }.takeWhile { i: Int -> i < 20 }.toList())
}
@test fun mapNotNull() {
@Test fun mapNotNull() {
assertEquals(listOf(0, 10, 110, 1220), fibonacci().mapNotNull { if (it % 5 == 0) it * 2 else null }.take(4).toList())
}
@test fun mapIndexedNotNull() {
@Test fun mapIndexedNotNull() {
// find which terms are divisible by their index
assertEquals(listOf("1/1", "5/5", "144/12", "46368/24", "75025/25"),
fibonacci().mapIndexedNotNull { index, value ->
@@ -78,38 +77,38 @@ public class SequenceTest {
}
@test fun mapAndJoinToString() {
@Test fun mapAndJoinToString() {
assertEquals("3, 5, 8", fibonacci().withIndex().filter { it.index > 3 }.take(3).joinToString { it.value.toString() })
}
@test fun withIndex() {
@Test fun withIndex() {
val data = sequenceOf("foo", "bar")
val indexed = data.withIndex().map { it.value.substring(0..it.index) }.toList()
assertEquals(listOf("f", "ba"), indexed)
}
@test fun filterAndTakeWhileExtractTheElementsWithinRange() {
@Test fun filterAndTakeWhileExtractTheElementsWithinRange() {
assertEquals(listOf(144, 233, 377, 610, 987), fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.toList())
}
@test fun foldReducesTheFirstNElements() {
@Test fun foldReducesTheFirstNElements() {
val sum = { a: Int, b: Int -> a + b }
assertEquals(listOf(13, 21, 34, 55, 89).fold(0, sum), fibonacci().filter { it > 10 }.take(5).fold(0, sum))
}
@test fun takeExtractsTheFirstNElements() {
@Test fun takeExtractsTheFirstNElements() {
assertEquals(listOf(0, 1, 1, 2, 3, 5, 8, 13, 21, 34), fibonacci().take(10).toList())
}
@test fun mapAndTakeWhileExtractTheTransformedElements() {
@Test fun mapAndTakeWhileExtractTheTransformedElements() {
assertEquals(listOf(0, 3, 3, 6, 9, 15), fibonacci().map { it * 3 }.takeWhile { i: Int -> i < 20 }.toList())
}
@test fun joinConcatenatesTheFirstNElementsAboveAThreshold() {
@Test fun joinConcatenatesTheFirstNElementsAboveAThreshold() {
assertEquals("13, 21, 34, 55, 89, ...", fibonacci().filter { it > 10 }.joinToString(separator = ", ", limit = 5))
}
@test fun drop() {
@Test fun drop() {
assertEquals(emptyList(), emptySequence<Int>().drop(1).toList())
listOf(2, 3, 4, 5).let { assertEquals(it, it.asSequence().drop(0).toList()) }
assertEquals("13, 21, 34, 55, 89, 144, 233, 377, 610, 987, ...", fibonacci().drop(7).joinToString(limit = 10))
@@ -117,7 +116,7 @@ public class SequenceTest {
assertFailsWith<IllegalArgumentException> { fibonacci().drop(-1) }
}
@test fun take() {
@Test fun take() {
assertEquals(emptyList(), emptySequence<Int>().take(1).toList())
assertEquals(emptyList(), fibonacci().take(0).toList())
@@ -131,7 +130,7 @@ public class SequenceTest {
assertFailsWith<IllegalArgumentException> { fibonacci().take(-1) }
}
@test fun subSequence() {
@Test fun subSequence() {
assertEquals(listOf(2, 3, 5, 8), fibonacci().drop(3).take(4).toList())
assertEquals(listOf(2, 3, 5, 8), fibonacci().take(7).drop(3).toList())
@@ -145,23 +144,23 @@ public class SequenceTest {
}
@test fun dropWhile() {
@Test fun dropWhile() {
assertEquals("233, 377, 610", fibonacci().dropWhile { it < 200 }.take(3).joinToString(limit = 10))
assertEquals("", sequenceOf(1).dropWhile { it < 200 }.joinToString(limit = 10))
}
@test fun zip() {
@Test fun zip() {
expect(listOf("ab", "bc", "cd")) {
sequenceOf("a", "b", "c").zip(sequenceOf("b", "c", "d")) { a, b -> a + b }.toList()
}
}
@test fun zipPairs() {
@Test fun zipPairs() {
val pairStr = (fibonacci() zip fibonacci().map { i -> i*2 }).joinToString(limit = 10)
assertEquals("(0, 0), (1, 2), (1, 2), (2, 4), (3, 6), (5, 10), (8, 16), (13, 26), (21, 42), (34, 68), ...", pairStr)
}
@test fun toStringJoinsNoMoreThanTheFirstTenElements() {
@Test fun toStringJoinsNoMoreThanTheFirstTenElements() {
assertEquals("0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...", fibonacci().joinToString(limit = 10))
assertEquals("13, 21, 34, 55, 89, 144, 233, 377, 610, 987, ...", fibonacci().filter { it > 10 }.joinToString(limit = 10))
assertEquals("144, 233, 377, 610, 987", fibonacci().filter { it > 100 }.takeWhile { it < 1000 }.joinToString())
@@ -176,12 +175,12 @@ public class SequenceTest {
}
@test fun plusElement() = testPlus { it + "cheese" + "wine" }
@test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
@test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
@test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
@Test fun plusElement() = testPlus { it + "cheese" + "wine" }
@Test fun plusCollection() = testPlus { it + listOf("cheese", "wine") }
@Test fun plusArray() = testPlus { it + arrayOf("cheese", "wine") }
@Test fun plusSequence() = testPlus { it + sequenceOf("cheese", "wine") }
@test fun plusAssign() {
@Test fun plusAssign() {
// lets use a mutable variable
var seq = sequenceOf("a")
seq += "foo"
@@ -198,12 +197,12 @@ public class SequenceTest {
assertEquals(expected_, b.toList())
}
@test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
@test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
@test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
@test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
@Test fun minusElement() = testMinus(expected = listOf("foo", "bar")) { it - "bar" - "zoo" }
@Test fun minusCollection() = testMinus { it - listOf("bar", "zoo") }
@Test fun minusArray() = testMinus { it - arrayOf("bar", "zoo") }
@Test fun minusSequence() = testMinus { it - sequenceOf("bar", "zoo") }
@test fun minusIsLazyIterated() {
@Test fun minusIsLazyIterated() {
val seq = sequenceOf("foo", "bar")
val list = arrayListOf<String>()
val result = seq - list
@@ -214,7 +213,7 @@ public class SequenceTest {
assertEquals(emptyList<String>(), result.toList())
}
@test fun minusAssign() {
@Test fun minusAssign() {
// lets use a mutable variable of readonly list
val data = sequenceOf("cheese", "foo", "beer", "cheese", "wine")
var l = data
@@ -229,7 +228,7 @@ public class SequenceTest {
@test fun iterationOverSequence() {
@Test fun iterationOverSequence() {
var s = ""
for (i in sequenceOf(0, 1, 2, 3, 4, 5)) {
s += i.toString()
@@ -237,7 +236,7 @@ public class SequenceTest {
assertEquals("012345", s)
}
@test fun sequenceFromFunction() {
@Test fun sequenceFromFunction() {
var count = 3
val sequence = generateSequence {
@@ -253,7 +252,7 @@ public class SequenceTest {
}
}
@test fun sequenceFromFunctionWithInitialValue() {
@Test fun sequenceFromFunctionWithInitialValue() {
val values = generateSequence(3) { n -> if (n > 0) n - 1 else null }
val expected = listOf(3, 2, 1, 0)
assertEquals(expected, values.toList())
@@ -279,7 +278,7 @@ public class SequenceTest {
}
@test fun sequenceFromIterator() {
@Test fun sequenceFromIterator() {
val list = listOf(3, 2, 1, 0)
val iterator = list.iterator()
val sequence = iterator.asSequence()
@@ -289,7 +288,7 @@ public class SequenceTest {
}
}
@test fun makeSequenceOneTimeConstrained() {
@Test fun makeSequenceOneTimeConstrained() {
val sequence = sequenceOf(1, 2, 3, 4)
sequence.toList()
sequence.toList()
@@ -309,13 +308,13 @@ public class SequenceTest {
return result
}
@test fun sequenceExtensions() {
@Test fun sequenceExtensions() {
val d = ArrayList<Int>()
sequenceOf(0, 1, 2, 3, 4, 5).takeWhileTo(d, { i -> i < 4 })
assertEquals(4, d.size)
}
@test fun flatMapAndTakeExtractTheTransformedElements() {
@Test fun flatMapAndTakeExtractTheTransformedElements() {
val expected = listOf(
'3', // fibonacci(4) = 3
'5', // fibonacci(5) = 5
@@ -329,22 +328,22 @@ public class SequenceTest {
assertEquals(expected, fibonacci().drop(4).flatMap { it.toString().asSequence() }.take(10).toList())
}
@test fun flatMap() {
@Test fun flatMap() {
val result = sequenceOf(1, 2).flatMap { (0..it).asSequence() }
assertEquals(listOf(0, 1, 0, 1, 2), result.toList())
}
@test fun flatMapOnEmpty() {
@Test fun flatMapOnEmpty() {
val result = sequenceOf<Int>().flatMap { (0..it).asSequence() }
assertTrue(result.none())
}
@test fun flatMapWithEmptyItems() {
@Test fun flatMapWithEmptyItems() {
val result = sequenceOf(1, 2, 4).flatMap { if (it == 2) sequenceOf<Int>() else (it - 1..it).asSequence() }
assertEquals(listOf(0, 1, 3, 4), result.toList())
}
@test fun flatten() {
@Test fun flatten() {
val expected = listOf(0, 1, 0, 1, 2)
val seq = sequenceOf((0..1).asSequence(), (0..2).asSequence()).flatten()
@@ -360,31 +359,31 @@ public class SequenceTest {
assertEquals(expected, seqMappedIterable.toList())
}
@test fun distinct() {
@Test fun distinct() {
val sequence = fibonacci().dropWhile { it < 10 }.take(20)
assertEquals(listOf(1, 2, 3, 0), sequence.map { it % 4 }.distinct().toList())
}
@test fun distinctBy() {
@Test fun distinctBy() {
val sequence = fibonacci().dropWhile { it < 10 }.take(20)
assertEquals(listOf(13, 34, 55, 144), sequence.distinctBy { it % 4 }.toList())
}
@test fun unzip() {
@Test fun unzip() {
val seq = sequenceOf(1 to 'a', 2 to 'b', 3 to 'c')
val (ints, chars) = seq.unzip()
assertEquals(listOf(1, 2, 3), ints)
assertEquals(listOf('a', 'b', 'c'), chars)
}
@test fun sorted() {
@Test fun sorted() {
sequenceOf(3, 7, 5).let {
it.sorted().iterator().assertSorted { a, b -> a <= b }
it.sortedDescending().iterator().assertSorted { a, b -> a >= b }
}
}
@test fun sortedBy() {
@Test fun sortedBy() {
sequenceOf("it", "greater", "less").let {
it.sortedBy { it.length }.iterator().assertSorted { a, b -> compareValuesBy(a, b) { it.length } <= 0 }
it.sortedByDescending { it.length }.iterator().assertSorted { a, b -> compareValuesBy(a, b) { it.length } >= 0 }
@@ -396,7 +395,7 @@ public class SequenceTest {
}
}
@test fun sortedWith() {
@Test fun sortedWith() {
val comparator = compareBy { s: String -> s.reversed() }
assertEquals(listOf("act", "wast", "test"), sequenceOf("act", "test", "wast").sortedWith(comparator).toList())
}