StdLib cleanup: replace fails with assertFails
This commit is contained in:
@@ -525,7 +525,7 @@ class ArraysTest {
|
||||
expect(0.toByte()) { byteArrayOf(3, 2, 1) reduce { a, b -> (a - b).toByte() } }
|
||||
expect(0.toShort()) { shortArrayOf(3, 2, 1) reduce { a, b -> (a - b).toShort() } }
|
||||
|
||||
assertTrue(fails {
|
||||
assertTrue(assertFails {
|
||||
intArrayOf().reduce { a, b -> a + b }
|
||||
} is UnsupportedOperationException)
|
||||
}
|
||||
@@ -541,7 +541,7 @@ class ArraysTest {
|
||||
expect(2.toByte()) { byteArrayOf(1, 2, 3) reduceRight { a, b -> (a - b).toByte() } }
|
||||
expect(2.toShort()) { shortArrayOf(1, 2, 3) reduceRight { a, b -> (a - b).toShort() } }
|
||||
|
||||
assertTrue(fails {
|
||||
assertTrue(assertFails {
|
||||
intArrayOf().reduceRight { a, b -> a + b }
|
||||
} is UnsupportedOperationException)
|
||||
}
|
||||
@@ -581,7 +581,7 @@ class ArraysTest {
|
||||
expect(listOf(false), { booleanArrayOf(true, false).drop(1) })
|
||||
expect(listOf('b'), { charArrayOf('a', 'b').drop(1) })
|
||||
expect(listOf("b"), { arrayOf("a", "b").drop(1) })
|
||||
fails {
|
||||
assertFails {
|
||||
listOf(2).drop(-1)
|
||||
}
|
||||
}
|
||||
@@ -599,7 +599,7 @@ class ArraysTest {
|
||||
expect(listOf(true), { booleanArrayOf(true, false).dropLast(1) })
|
||||
expect(listOf('a'), { charArrayOf('a', 'b').dropLast(1) })
|
||||
expect(listOf("a"), { arrayOf("a", "b").dropLast(1) })
|
||||
fails {
|
||||
assertFails {
|
||||
listOf(1).dropLast(-1)
|
||||
}
|
||||
}
|
||||
@@ -645,7 +645,7 @@ class ArraysTest {
|
||||
expect(listOf(true), { booleanArrayOf(true, false).take(1) })
|
||||
expect(listOf('a'), { charArrayOf('a', 'b').take(1) })
|
||||
expect(listOf("a"), { arrayOf("a", "b").take(1) })
|
||||
fails {
|
||||
assertFails {
|
||||
listOf(1).take(-1)
|
||||
}
|
||||
}
|
||||
@@ -663,7 +663,7 @@ class ArraysTest {
|
||||
expect(listOf(false), { booleanArrayOf(true, false).takeLast(1) })
|
||||
expect(listOf('b'), { charArrayOf('a', 'b').takeLast(1) })
|
||||
expect(listOf("b"), { arrayOf("a", "b").takeLast(1) })
|
||||
fails {
|
||||
assertFails {
|
||||
listOf(1).takeLast(-1)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -109,7 +109,7 @@ class CollectionJVMTest {
|
||||
}
|
||||
|
||||
@test fun lastException() {
|
||||
fails { linkedListOf<String>().last() }
|
||||
assertFails { linkedListOf<String>().last() }
|
||||
}
|
||||
|
||||
@test fun contains() {
|
||||
|
||||
@@ -163,7 +163,7 @@ class CollectionTest {
|
||||
|
||||
// TODO replace with more accurate version when KT-5987 will be fixed
|
||||
// failsWith(javaClass<UnsupportedOperationException>()) {
|
||||
fails {
|
||||
assertFails {
|
||||
run { arrayListOf<Int>().reduce { a, b -> a + b } }
|
||||
}
|
||||
}
|
||||
@@ -176,7 +176,7 @@ class CollectionTest {
|
||||
|
||||
// TODO replace with more accurate version when KT-5987 will be fixed
|
||||
// failsWith(javaClass<UnsupportedOperationException>()) {
|
||||
fails {
|
||||
assertFails {
|
||||
run { arrayListOf<Int>().reduceRight { a, b -> a + b } }
|
||||
}
|
||||
}
|
||||
@@ -302,7 +302,7 @@ class CollectionTest {
|
||||
|
||||
// TODO replace with more accurate version when KT-5987 will be fixed
|
||||
// failsWith(javaClass<IllegalArgumentException>()) {
|
||||
fails {
|
||||
assertFails {
|
||||
// should throw an exception as we have a null
|
||||
hasNulls.requireNoNulls()
|
||||
}
|
||||
@@ -346,7 +346,7 @@ class CollectionTest {
|
||||
assertEquals(listOf("foo", "bar"), coll.dropLast(1))
|
||||
assertEquals(listOf("foo"), coll.dropLast(2))
|
||||
|
||||
fails { coll.dropLast(-1) }
|
||||
assertFails { coll.dropLast(-1) }
|
||||
}
|
||||
|
||||
@test fun dropLastWhile() {
|
||||
@@ -365,7 +365,7 @@ class CollectionTest {
|
||||
assertEquals(coll, coll.take(coll.size()))
|
||||
assertEquals(coll, coll.take(coll.size() + 1))
|
||||
|
||||
fails { coll.take(-1) }
|
||||
assertFails { coll.take(-1) }
|
||||
}
|
||||
|
||||
@test fun takeWhile() {
|
||||
@@ -385,7 +385,7 @@ class CollectionTest {
|
||||
assertEquals(coll, coll.takeLast(coll.size()))
|
||||
assertEquals(coll, coll.takeLast(coll.size() + 1))
|
||||
|
||||
fails { coll.takeLast(-1) }
|
||||
assertFails { coll.takeLast(-1) }
|
||||
}
|
||||
|
||||
@test fun takeLastWhile() {
|
||||
@@ -420,7 +420,7 @@ class CollectionTest {
|
||||
assertEquals("foo", data.first())
|
||||
assertEquals(15, listOf(15, 19, 20, 25).first())
|
||||
assertEquals('a', listOf('a').first())
|
||||
fails { arrayListOf<Int>().first() }
|
||||
assertFails { arrayListOf<Int>().first() }
|
||||
}
|
||||
|
||||
@test fun last() {
|
||||
@@ -428,7 +428,7 @@ class CollectionTest {
|
||||
assertEquals("bar", data.last())
|
||||
assertEquals(25, listOf(15, 19, 20, 25).last())
|
||||
assertEquals('a', listOf('a').last())
|
||||
fails { arrayListOf<Int>().last() }
|
||||
assertFails { arrayListOf<Int>().last() }
|
||||
}
|
||||
|
||||
@test fun subscript() {
|
||||
@@ -437,7 +437,7 @@ class CollectionTest {
|
||||
assertEquals("bar", list[1])
|
||||
|
||||
// lists throw an exception if out of range
|
||||
fails {
|
||||
assertFails {
|
||||
assertEquals(null, list[2])
|
||||
}
|
||||
|
||||
@@ -446,7 +446,7 @@ class CollectionTest {
|
||||
list[1] = "thing"
|
||||
|
||||
// lists don't allow you to set past the end of the list
|
||||
fails {
|
||||
assertFails {
|
||||
list[2] = "works"
|
||||
}
|
||||
|
||||
|
||||
@@ -20,8 +20,8 @@ public class CompareContext<out T>(public val expected: T, public val actual: T)
|
||||
}
|
||||
|
||||
private fun assertFailEquals(expected: () -> Unit, actual: () -> Unit) {
|
||||
val expectedFail = fails(expected)
|
||||
val actualFail = fails(actual)
|
||||
val expectedFail = assertFails(expected)
|
||||
val actualFail = assertFails(actual)
|
||||
//assertEquals(expectedFail != null, actualFail != null)
|
||||
assertTypeEquals(expectedFail, actualFail)
|
||||
}
|
||||
|
||||
@@ -56,9 +56,9 @@ abstract class OrderedIterableTests<T : Iterable<String>>(data: T, empty: T) : I
|
||||
fun elementAt() {
|
||||
expect("foo") { data.elementAt(0) }
|
||||
expect("bar") { data.elementAt(1) }
|
||||
fails { data.elementAt(2) }
|
||||
fails { data.elementAt(-1) }
|
||||
fails { empty.elementAt(0) }
|
||||
assertFails { data.elementAt(2) }
|
||||
assertFails { data.elementAt(-1) }
|
||||
assertFails { empty.elementAt(0) }
|
||||
|
||||
expect("foo") { data.elementAtOrElse(0, {""} )}
|
||||
expect("zoo") { data.elementAtOrElse(-1, { "zoo" })}
|
||||
@@ -72,10 +72,10 @@ abstract class OrderedIterableTests<T : Iterable<String>>(data: T, empty: T) : I
|
||||
@Test
|
||||
fun first() {
|
||||
expect("foo") { data.first() }
|
||||
fails {
|
||||
assertFails {
|
||||
data.first { it.startsWith("x") }
|
||||
}
|
||||
fails {
|
||||
assertFails {
|
||||
empty.first()
|
||||
}
|
||||
expect("foo") { data.first { it.startsWith("f") } }
|
||||
@@ -93,10 +93,10 @@ abstract class OrderedIterableTests<T : Iterable<String>>(data: T, empty: T) : I
|
||||
@Test
|
||||
fun last() {
|
||||
assertEquals("bar", data.last())
|
||||
fails {
|
||||
assertFails {
|
||||
data.last { it.startsWith("x") }
|
||||
}
|
||||
fails {
|
||||
assertFails {
|
||||
empty.last()
|
||||
}
|
||||
expect("foo") { data.last { it.startsWith("f") } }
|
||||
@@ -190,11 +190,11 @@ abstract class IterableTests<T : Iterable<String>>(val data: T, val empty: T) {
|
||||
|
||||
@Test
|
||||
fun single() {
|
||||
fails { data.single() }
|
||||
fails { empty.single() }
|
||||
assertFails { data.single() }
|
||||
assertFails { empty.single() }
|
||||
expect("foo") { data.single { it.startsWith("f") } }
|
||||
expect("bar") { data.single { it.startsWith("b") } }
|
||||
fails {
|
||||
assertFails {
|
||||
data.single { it.length() == 3 }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -35,9 +35,9 @@ class ListSpecificTest {
|
||||
fun getOr() {
|
||||
expect("foo") { data.get(0) }
|
||||
expect("bar") { data.get(1) }
|
||||
fails { data.get(2) }
|
||||
fails { data.get(-1) }
|
||||
fails { empty.get(0) }
|
||||
assertFails { data.get(2) }
|
||||
assertFails { data.get(-1) }
|
||||
assertFails { empty.get(0) }
|
||||
|
||||
expect("foo") { data.getOrElse(0, {""} )}
|
||||
expect("zoo") { data.getOrElse(-1, { "zoo" })}
|
||||
|
||||
@@ -43,7 +43,7 @@ class MapJVMTest {
|
||||
@test fun getOrPutFailsOnConcurrentMap() {
|
||||
val map = ConcurrentHashMap<String, Int>()
|
||||
|
||||
fails {
|
||||
assertFails {
|
||||
map.getOrPut("x") { 1 }
|
||||
}
|
||||
expect(1) {
|
||||
|
||||
@@ -1,10 +1,7 @@
|
||||
package test.collections
|
||||
|
||||
import java.util.*
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.fails
|
||||
import kotlin.test.*
|
||||
import org.junit.Test as test
|
||||
|
||||
class MapTest {
|
||||
@@ -25,7 +22,7 @@ class MapTest {
|
||||
|
||||
@test fun getOrImplicitDefault() {
|
||||
val data: MutableMap<String, Int> = hashMapOf("bar" to 1)
|
||||
assertTrue(fails { data.getOrImplicitDefault("foo") } is NoSuchElementException)
|
||||
assertTrue(assertFails { data.getOrImplicitDefault("foo") } is NoSuchElementException)
|
||||
assertEquals(1, data.getOrImplicitDefault("bar"))
|
||||
|
||||
val mutableWithDefault = data.withDefault { 42 }
|
||||
|
||||
@@ -39,7 +39,7 @@ public class SequenceTest {
|
||||
|
||||
val sequenceWithNulls = sequenceOf("foo", null, "bar")
|
||||
val notNull2 = sequenceWithNulls.requireNoNulls() // shouldn't fail yet
|
||||
fails {
|
||||
assertFails {
|
||||
// should throw an exception as we have a null
|
||||
notNull2.toList()
|
||||
}
|
||||
@@ -213,7 +213,7 @@ public class SequenceTest {
|
||||
val list = sequence.toList()
|
||||
assertEquals(listOf(2, 1, 0), list)
|
||||
|
||||
fails {
|
||||
assertFails {
|
||||
sequence.toList()
|
||||
}
|
||||
}
|
||||
@@ -231,7 +231,7 @@ public class SequenceTest {
|
||||
val iterator = list.iterator()
|
||||
val sequence = iterator.asSequence()
|
||||
assertEquals(list, sequence.toList())
|
||||
fails {
|
||||
assertFails {
|
||||
sequence.toList()
|
||||
}
|
||||
}
|
||||
@@ -244,7 +244,7 @@ public class SequenceTest {
|
||||
val oneTime = sequence.constrainOnce()
|
||||
oneTime.toList()
|
||||
assertTrue("should fail with IllegalStateException") {
|
||||
fails {
|
||||
assertFails {
|
||||
oneTime.toList()
|
||||
} is IllegalStateException
|
||||
}
|
||||
|
||||
@@ -2,8 +2,8 @@ package iterators
|
||||
|
||||
import kotlin.test.assertEquals
|
||||
import org.junit.Test as test
|
||||
import kotlin.test.fails
|
||||
import java.util.ArrayList
|
||||
import kotlin.test.assertFails
|
||||
|
||||
fun fibonacci(): Sequence<Int> {
|
||||
// fibonacci terms
|
||||
@@ -71,7 +71,7 @@ class IteratorsTest {
|
||||
|
||||
val iterWithNulls = arrayListOf("foo", null, "bar").asSequence()
|
||||
val notNull2 = iterWithNulls.requireNoNulls()
|
||||
fails {
|
||||
assertFails {
|
||||
// should throw an exception as we have a null
|
||||
notNull2.toList()
|
||||
}
|
||||
|
||||
@@ -33,7 +33,7 @@ public class RangeTest {
|
||||
assertTrue(9 in openRange)
|
||||
assertFalse(10 in openRange)
|
||||
|
||||
assertTrue(fails { 1 until Int.MIN_VALUE } is IllegalArgumentException)
|
||||
assertTrue(assertFails { 1 until Int.MIN_VALUE } is IllegalArgumentException)
|
||||
}
|
||||
|
||||
@test fun byteRange() {
|
||||
@@ -66,7 +66,7 @@ public class RangeTest {
|
||||
assertTrue(9.toByte() in openRange)
|
||||
assertFalse(10.toByte() in openRange)
|
||||
|
||||
assertTrue(fails { 0.toByte() until Byte.MIN_VALUE } is IllegalArgumentException)
|
||||
assertTrue(assertFails { 0.toByte() until Byte.MIN_VALUE } is IllegalArgumentException)
|
||||
|
||||
}
|
||||
|
||||
@@ -99,7 +99,7 @@ public class RangeTest {
|
||||
assertTrue(9.toShort() in openRange)
|
||||
assertFalse(10.toShort() in openRange)
|
||||
|
||||
assertTrue(fails { 0.toShort() until Short.MIN_VALUE } is IllegalArgumentException)
|
||||
assertTrue(assertFails { 0.toShort() until Short.MIN_VALUE } is IllegalArgumentException)
|
||||
}
|
||||
|
||||
@test fun longRange() {
|
||||
@@ -131,7 +131,7 @@ public class RangeTest {
|
||||
assertTrue(9L in openRange)
|
||||
assertFalse(10L in openRange)
|
||||
|
||||
assertTrue(fails { 0L until Long.MIN_VALUE } is IllegalArgumentException)
|
||||
assertTrue(assertFails { 0L until Long.MIN_VALUE } is IllegalArgumentException)
|
||||
|
||||
}
|
||||
|
||||
@@ -156,7 +156,7 @@ public class RangeTest {
|
||||
assertTrue('Y' in openRange)
|
||||
assertFalse('Z' in openRange)
|
||||
|
||||
assertTrue(fails { 'A' until '\u0000' } is IllegalArgumentException)
|
||||
assertTrue(assertFails { 'A' until '\u0000' } is IllegalArgumentException)
|
||||
}
|
||||
|
||||
@test fun doubleRange() {
|
||||
|
||||
@@ -36,8 +36,8 @@ class CoercionTest {
|
||||
assertTrue((value coerceIn range) in range)
|
||||
}
|
||||
|
||||
fails { 1.coerceIn(1, 0) }
|
||||
fails { 1.coerceIn(1..0) }
|
||||
assertFails { 1.coerceIn(1, 0) }
|
||||
assertFails { 1.coerceIn(1..0) }
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -59,8 +59,8 @@ class CoercionTest {
|
||||
assertTrue((value coerceIn range) in range)
|
||||
}
|
||||
|
||||
fails { 1L.coerceIn(1L, 0L) }
|
||||
fails { 1L.coerceIn(1L..0L) }
|
||||
assertFails { 1L.coerceIn(1L, 0L) }
|
||||
assertFails { 1L.coerceIn(1L..0L) }
|
||||
|
||||
}
|
||||
|
||||
@@ -83,8 +83,8 @@ class CoercionTest {
|
||||
assertTrue((value coerceIn range) in range)
|
||||
}
|
||||
|
||||
fails { 1.0.coerceIn(1.0, 0.0) }
|
||||
fails { 1.0.coerceIn(1.0..0.0) }
|
||||
assertFails { 1.0.coerceIn(1.0, 0.0) }
|
||||
assertFails { 1.0.coerceIn(1.0..0.0) }
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -111,8 +111,8 @@ class CoercionTest {
|
||||
assertTrue((value coerceIn range) in range)
|
||||
}
|
||||
|
||||
fails { v[1].coerceIn(v[1], v[0]) }
|
||||
fails { v[1].coerceIn(v[1]..v[0]) }
|
||||
assertFails { v[1].coerceIn(v[1], v[0]) }
|
||||
assertFails { v[1].coerceIn(v[1]..v[0]) }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -25,7 +25,7 @@ class ValByMapExtensionsTest {
|
||||
assertEquals("default", e)
|
||||
assertEquals(1, i)
|
||||
assertEquals(1.0, x)
|
||||
assertTrue(fails { d } is NoSuchElementException)
|
||||
assertTrue(assertFails { d } is NoSuchElementException)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -60,7 +60,7 @@ class VarByMapExtensionsTest {
|
||||
map["a"] = null
|
||||
a // fails { a } // does not fail due to KT-8135
|
||||
|
||||
assertTrue(fails { d } is NoSuchElementException)
|
||||
assertTrue(assertFails { d } is NoSuchElementException)
|
||||
map["d"] = null
|
||||
assertEquals(null, d)
|
||||
}
|
||||
|
||||
@@ -68,13 +68,13 @@ class StringJVMTest {
|
||||
// deprecation replacement equivalence
|
||||
assertEquals("\\d".toPattern().split(s).toList(), s.split("\\d".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray().toList())
|
||||
|
||||
fails {
|
||||
assertFails {
|
||||
s.split(isDigit, -1)
|
||||
}
|
||||
}
|
||||
|
||||
@test fun repeat() {
|
||||
fails{ "foo".repeat(-1) }
|
||||
assertFails { "foo".repeat(-1) }
|
||||
assertEquals("", "foo".repeat(0))
|
||||
assertEquals("foo", "foo".repeat(1))
|
||||
assertEquals("foofoo", "foo".repeat(2))
|
||||
@@ -269,7 +269,7 @@ class StringJVMTest {
|
||||
@test fun drop() {
|
||||
val data = "abcd1234"
|
||||
assertEquals("d1234", data.drop(3))
|
||||
fails {
|
||||
assertFails {
|
||||
data.drop(-2)
|
||||
}
|
||||
assertEquals("", data.drop(data.length() + 5))
|
||||
@@ -285,7 +285,7 @@ class StringJVMTest {
|
||||
@test fun take() {
|
||||
val data = "abcd1234"
|
||||
assertEquals("abc", data.take(3))
|
||||
fails {
|
||||
assertFails {
|
||||
data.take(-7)
|
||||
}
|
||||
assertEquals(data, data.take(data.length() + 42))
|
||||
@@ -351,10 +351,10 @@ class StringJVMTest {
|
||||
assertEquals("baD", builder.slice(5 downTo 3))
|
||||
assertEquals("aDAB", builder.slice(iter))
|
||||
|
||||
fails {
|
||||
assertFails {
|
||||
"abc".slice(listOf(1,4))
|
||||
}
|
||||
fails {
|
||||
assertFails {
|
||||
builder.slice(listOf(10))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
package test.text
|
||||
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.fails
|
||||
import kotlin.test.*
|
||||
import org.junit.Test as test
|
||||
|
||||
// could not be local inside isEmptyAndBlank, because non-toplevel declarations is not yet supported for JS
|
||||
@@ -146,10 +143,10 @@ class StringTest {
|
||||
val s = "sample text"
|
||||
assertEquals("sa??e text", s.replaceRange(2, 5, "??"))
|
||||
assertEquals("sa?? text", s.replaceRange(2..5, "??"))
|
||||
fails {
|
||||
assertFails {
|
||||
s.replaceRange(5..2, "??")
|
||||
}
|
||||
fails {
|
||||
assertFails {
|
||||
s.replaceRange(5, 2, "??")
|
||||
}
|
||||
|
||||
@@ -298,7 +295,7 @@ class StringTest {
|
||||
assertEquals("s", "s".padStart(1))
|
||||
assertEquals(" ", "".padStart(2))
|
||||
assertEquals("--s", "s".padStart(3, '-'))
|
||||
fails {
|
||||
assertFails {
|
||||
"s".padStart(-1)
|
||||
}
|
||||
}
|
||||
@@ -308,7 +305,7 @@ class StringTest {
|
||||
assertEquals("s", "s".padEnd(1))
|
||||
assertEquals(" ", "".padEnd(2))
|
||||
assertEquals("s--", "s".padEnd(3, '-'))
|
||||
fails {
|
||||
assertFails {
|
||||
"s".padEnd(-1)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -27,11 +27,11 @@ private class PartiallyImplementedClass {
|
||||
|
||||
class TODOTest {
|
||||
private fun assertNotImplemented(block: () -> Unit) {
|
||||
assertTrue(fails(block) is NotImplementedError)
|
||||
assertTrue(assertFails(block) is NotImplementedError)
|
||||
}
|
||||
|
||||
private fun assertNotImplementedWithMessage(message: String, block: () -> Unit) {
|
||||
val e = fails(block)
|
||||
val e = assertFails(block)
|
||||
assertTrue(e is NotImplementedError)
|
||||
assertTrue(message in e!!.getMessage()!!)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user