franklinblanco
/
kotlin-result
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Improve consistency across unit tests

This commit is contained in:
Michael Bull 2024-03-05 17:36:19 +00:00
parent 4e5cdeede7
commit f05ce6e0c7
14 changed files with 289 additions and 366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
kotlin-result-coroutines/src/commonTest/kotlin/com.github.michaelbull.result.coroutines/binding/SuspendableBindingTest.kt
View File

@ -36,7 +36,7 @@ class SuspendableBindingTest {
assertEquals(
expected = Ok(3),
actual = result
actual = result,
)
}
@ -60,7 +60,7 @@ class SuspendableBindingTest {
assertEquals(
expected = Ok(3),
actual = result
actual = result,
)
}
@ -90,7 +90,7 @@ class SuspendableBindingTest {
assertEquals(
expected = Err(BindingError),
actual = result
actual = result,
)
}
@ -127,7 +127,7 @@ class SuspendableBindingTest {
assertEquals(
expected = Err(BindingError),
actual = result
actual = result,
)
assertTrue(xStateChange)
@ -161,7 +161,7 @@ class SuspendableBindingTest {
assertEquals(
expected = Err(BindingError),
actual = result
actual = result,
)
}
}

16
kotlin-result-coroutines/src/jsTest/kotlin/com.github.michaelbull.result.coroutines/binding/AsyncSuspendableBindingTest.kt
View File

@ -15,9 +15,9 @@ import kotlin.test.assertTrue
@ExperimentalCoroutinesApi
class AsyncSuspendableBindingTest {
private sealed class BindingError {
object BindingErrorA : BindingError()
object BindingErrorB : BindingError()
private sealed interface BindingError {
data object BindingErrorA : BindingError
data object BindingErrorB : BindingError
}
@Test
@ -32,7 +32,7 @@ class AsyncSuspendableBindingTest {
return Ok(2)
}
val result = binding<Int, BindingError> {
val result = binding {
val x = async { provideX().bind() }
val y = async { provideY().bind() }
x.await() + y.await()
@ -40,7 +40,7 @@ class AsyncSuspendableBindingTest {
assertEquals(
expected = Ok(3),
actual = result
actual = result,
)
}
@ -61,7 +61,7 @@ class AsyncSuspendableBindingTest {
return Err(BindingError.BindingErrorB)
}
val result = binding<Int, BindingError> {
val result = binding {
val x = async { provideX().bind() }
val y = async { provideY().bind() }
val z = async { provideZ().bind() }
@ -98,7 +98,7 @@ class AsyncSuspendableBindingTest {
return Err(BindingError.BindingErrorB)
}
val result = binding<Int, BindingError> {
val result = binding {
val x = async { provideX().bind() }
val y = async { provideY().bind() }
val z = async { provideZ().bind() }
@ -108,7 +108,7 @@ class AsyncSuspendableBindingTest {
assertEquals(
expected = Err(BindingError.BindingErrorB),
actual = result
actual = result,
)
assertFalse(xStateChange)

4
kotlin-result-coroutines/src/jvmTest/kotlin/com/github/michaelbull/result/coroutines/RunSuspendCatchingTest.kt
View File

@ -49,7 +49,7 @@ class RunSuspendCatchingTest {
assertEquals(
expected = Ok("example"),
actual = result
actual = result,
)
}
@ -61,7 +61,7 @@ class RunSuspendCatchingTest {
assertEquals(
expected = Err(exception),
actual = result
actual = result,
)
}
}

21
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/AndTest.kt
View File

@ -2,43 +2,44 @@ package com.github.michaelbull.result
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertSame
class AndTest {
private object AndError
class And {
@Test
fun returnsValueIfOk() {
assertEquals(
expected = 500,
actual = Ok(230).and(Ok(500)).get()
expected = Ok(500),
actual = Ok(230).and(Ok(500)),
)
}
@Test
fun returnsValueIfErr() {
assertEquals(
expected = "hello world",
actual = Ok(300).and(Err("hello world")).getError()
expected = Err("hello world"),
actual = Ok(300).and(Err("hello world")),
)
}
}
class AndThen {
@Test
fun returnsTransformedValueIfOk() {
assertEquals(
expected = 12,
actual = Ok(5).andThen { Ok(it + 7) }.get()
expected = Ok(12),
actual = Ok(5).andThen { Ok(it + 7) },
)
}
@Test
fun returnsErrorIfErr() {
assertSame(
expected = AndError,
actual = Ok(20).andThen { Ok(it + 43) }.andThen { Err(AndError) }.getError()!!
assertEquals(
expected = Err(AndError),
actual = Ok(20).andThen { Ok(it + 43) }.andThen { Err(AndError) },
)
}
}

31
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/BindingTest.kt
View File

@ -2,7 +2,6 @@ package com.github.michaelbull.result
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
class BindingTest {
@ -13,14 +12,16 @@ class BindingTest {
fun provideX(): Result<Int, BindingError> = Ok(1)
fun provideY(): Result<Int, BindingError> = Ok(2)
val result = binding<Int, BindingError> {
val result = binding {
val x = provideX().bind()
val y = provideY().bind()
x + y
}
assertTrue(result is Ok)
assertEquals(3, result.value)
assertEquals(
expected = Ok(3),
actual = result,
)
}
@Test
@ -28,14 +29,16 @@ class BindingTest {
fun provideX(): Result<String, BindingError> = Ok("1")
fun provideY(x: Int): Result<Int, BindingError> = Ok(x + 2)
val result = binding<Int, BindingError> {
val result = binding {
val x = provideX().bind()
val y = provideY(x.toInt()).bind()
y
}
assertTrue(result is Ok)
assertEquals(3, result.value)
assertEquals(
expected = Ok(3),
actual = result,
)
}
@Test
@ -44,15 +47,17 @@ class BindingTest {
fun provideY(): Result<Int, BindingError> = Err(BindingError)
fun provideZ(): Result<Int, BindingError> = Ok(2)
val result = binding<Int, BindingError> {
val result = binding {
val x = provideX().bind()
val y = provideY().bind()
val z = provideZ().bind()
x + y + z
}
assertTrue(result is Err)
assertEquals(BindingError, result.error)
assertEquals(
expected = Err(BindingError),
actual = result,
)
}
@Test
@ -68,7 +73,9 @@ class BindingTest {
x + y.toInt() + z
}
assertTrue(result is Err)
assertEquals(BindingError, result.error)
assertEquals(
expected = Err(BindingError),
actual = result,
)
}
}

29
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/FactoryTest.kt
View File

@ -2,52 +2,45 @@ package com.github.michaelbull.result
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertSame
class FactoryTest {
class RunCatching {
@Test
fun returnsOkIfInvocationSuccessful() {
val callback = { "example" }
val result = runCatching(callback)
assertEquals(
expected = "example",
actual = result.get()
expected = Ok("example"),
actual = runCatching { "example" },
)
}
@Test
@Suppress("UNREACHABLE_CODE")
fun returnsErrIfInvocationFails() {
val exception = IllegalArgumentException("throw me")
val callback = { throw exception }
val result = runCatching(callback)
assertSame(
expected = exception,
actual = result.getError()
assertEquals(
expected = Err(exception),
actual = runCatching { throw exception },
)
}
}
class ToResultOr {
@Test
fun returnsOkfIfNonNull() {
val result = "ok".toResultOr { "err" }
assertEquals(
expected = "ok",
actual = result.get()
actual = "ok".toResultOr { "err" }.get()
)
}
@Test
fun returnsErrIfNull() {
val result = "ok".toLongOrNull().toResultOr { "err" }
assertEquals(
expected = "err",
actual = result.getError()
expected = Err("err"),
actual = "ok".toLongOrNull().toResultOr { "err" }
)
}
}

34
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/GetTest.kt
View File

@ -86,7 +86,7 @@ class GetTest {
@Test
fun throwsTransformedErrorIfErr() {
assertFailsWith<CustomException> {
Err("error").getOrThrow { error -> CustomException(error) }
Err("error").getOrThrow(::CustomException)
}
}
@ -148,19 +148,43 @@ class GetTest {
}
class Merge {
interface Direction
object Left : Direction
object Right : Direction
@Test
fun returnsValueIfOk() {
val left: Result<Left, Left> = Ok(Left)
val right: Result<Right, Right> = Ok(Right)
val result: Result<Direction, Direction> = left.flatMapEither(
success = { left },
failure = { right },
)
val direction: Direction = result.merge()
assertEquals(
expected = setOf(4, 5, 6),
actual = Ok(listOf(1, 2, 3)).and(Ok(setOf(4, 5, 6))).merge()
expected = Left,
actual = direction
)
}
@Test
fun returnsErrorIfErr() {
val left: Result<Left, Left> = Err(Left)
val right: Result<Right, Right> = Err(Right)
val result: Result<Direction, Direction> = left.flatMapEither(
success = { left },
failure = { right },
)
val direction: Direction = result.merge()
assertEquals(
expected = listOf(1, 2, 3),
actual = Err(listOf(1, 2, 3)).and(Err(setOf(4, 5, 6))).merge()
expected = Right,
actual = direction
)
}
}

224
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/IterableTest.kt
View File

@ -2,27 +2,25 @@ package com.github.michaelbull.result
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertSame
class IterableTest {
private sealed class IterableError {
object IterableError1 : IterableError()
object IterableError2 : IterableError()
private sealed interface IterableError {
data object IterableError1 : IterableError
data object IterableError2 : IterableError
}
class Fold {
@Test
fun returnAccumulatedValueIfOk() {
val result = listOf(20, 30, 40, 50).fold(
initial = 10,
operation = { a, b -> Ok(a + b) }
operation = { a, b -> Ok(a + b) },
)
result as Ok
assertEquals(
expected = 150,
actual = result.value
expected = Ok(150),
actual = result,
)
}
@ -36,31 +34,28 @@ class IterableTest {
(5 + 10 + 15 + 20) -> Err(IterableError.IterableError2)
else -> Ok(a * b)
}
}
},
)
result as Err
assertSame(
expected = IterableError.IterableError1,
actual = result.error
assertEquals(
expected = Err(IterableError.IterableError1),
actual = result,
)
}
}
class FoldRight {
@Test
fun returnsAccumulatedValueIfOk() {
val result = listOf(2, 5, 10, 20).foldRight(
initial = 100,
operation = { a, b -> Ok(b - a) }
operation = { a, b -> Ok(b - a) },
)
result as Ok
assertEquals(
expected = 63,
actual = result.value
expected = Ok(63),
actual = result,
)
}
@ -74,45 +69,29 @@ class IterableTest {
((38500 / 40) / 20) -> Err(IterableError.IterableError2)
else -> Ok(b / a)
}
}
},
)
result as Err
assertSame(
expected = IterableError.IterableError2,
actual = result.error
assertEquals(
expected = Err(IterableError.IterableError2),
actual = result,
)
}
}
class Combine {
@Test
fun returnsValuesIfAllOk() {
val values = combine(
val result = combine(
Ok(10),
Ok(20),
Ok(30)
).get()!!
assertEquals(
expected = 3,
actual = values.size
Ok(30),
)
assertEquals(
expected = 10,
actual = values[0]
)
assertEquals(
expected = 20,
actual = values[1]
)
assertEquals(
expected = 30,
actual = values[2]
expected = Ok(listOf(10, 20, 30)),
actual = result,
)
}
@ -124,61 +103,41 @@ class IterableTest {
Err(IterableError.IterableError1),
Ok(60),
Err(IterableError.IterableError2),
Ok(80)
Ok(80),
)
result as Err
assertSame(
expected = IterableError.IterableError1,
actual = result.error
assertEquals(
expected = Err(IterableError.IterableError1),
actual = result,
)
}
}
class GetAll {
@Test
fun returnsAllValues() {
val values = getAll(
val result = getAll(
Ok("hello"),
Ok("big"),
Err(IterableError.IterableError2),
Ok("wide"),
Err(IterableError.IterableError1),
Ok("world")
Ok("world"),
)
assertEquals(
expected = 4,
actual = values.size
)
assertEquals(
expected = "hello",
actual = values[0]
)
assertEquals(
expected = "big",
actual = values[1]
)
assertEquals(
expected = "wide",
actual = values[2]
)
assertEquals(
expected = "world",
actual = values[3]
expected = listOf("hello", "big", "wide", "world"),
actual = result
)
}
}
class GetAllErrors {
@Test
fun returnsAllErrors() {
val errors = getAllErrors(
val result = getAllErrors(
Err(IterableError.IterableError2),
Ok("haskell"),
Err(IterableError.IterableError2),
@ -187,45 +146,42 @@ class IterableTest {
Ok("elm"),
Err(IterableError.IterableError1),
Ok("clojure"),
Err(IterableError.IterableError2)
Err(IterableError.IterableError2),
)
assertEquals(
expected = 5,
actual = errors.size
)
assertSame(
expected = IterableError.IterableError2,
actual = errors[0]
)
assertSame(
expected = IterableError.IterableError2,
actual = errors[1]
)
assertSame(
expected = IterableError.IterableError1,
actual = errors[2]
)
assertSame(
expected = IterableError.IterableError1,
actual = errors[3]
)
assertSame(
expected = IterableError.IterableError2,
actual = errors[4]
expected = listOf(
IterableError.IterableError2,
IterableError.IterableError2,
IterableError.IterableError1,
IterableError.IterableError1,
IterableError.IterableError2,
),
actual = result
)
}
}
class Partition {
@Test
fun returnsPairOfValuesAndErrors() {
val pairs = partition(
val strings = listOf(
"haskell",
"f#",
"elm",
"clojure",
)
val errors = listOf(
IterableError.IterableError2,
IterableError.IterableError2,
IterableError.IterableError1,
IterableError.IterableError1,
IterableError.IterableError2,
)
val result = partition(
Err(IterableError.IterableError2),
Ok("haskell"),
Err(IterableError.IterableError2),
@ -237,63 +193,9 @@ class IterableTest {
Err(IterableError.IterableError2)
)
val values = pairs.first
assertEquals(
expected = 4,
actual = values.size
)
assertEquals(
expected = "haskell",
actual = values[0]
)
assertEquals(
expected = "f#",
actual = values[1]
)
assertEquals(
expected = "elm",
actual = values[2]
)
assertEquals(
expected = "clojure",
actual = values[3]
)
val errors = pairs.second
assertEquals(
expected = 5,
actual = errors.size
)
assertSame(
expected = IterableError.IterableError2,
actual = errors[0]
)
assertSame(
expected = IterableError.IterableError2,
actual = errors[1]
)
assertSame(
expected = IterableError.IterableError1,
actual = errors[2]
)
assertSame(
expected = IterableError.IterableError1,
actual = errors[3]
)
assertSame(
expected = IterableError.IterableError2,
actual = errors[4]
expected = Pair(strings, errors),
actual = result,
)
}
}

2
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/OnTest.kt
View File

@ -8,6 +8,7 @@ class OnTest {
class Counter(var count: Int)
class OnSuccess {
@Test
fun invokesActionIfOk() {
val counter = Counter(50)
@ -34,6 +35,7 @@ class OnTest {
}
class OnFailure {
@Test
fun invokesActionIfErr() {
val counter = Counter(555)

55
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/OrTest.kt
View File

@ -8,19 +8,20 @@ class OrTest {
private object OrError
class Or {
@Test
fun returnsValueIfOk() {
assertEquals(
expected = 500,
actual = Ok(500).or(Ok(1000)).get()
expected = Ok(500),
actual = Ok(500).or(Ok(1000))
)
}
@Test
fun returnsDefaultValueIfErr() {
assertEquals(
expected = 5000,
actual = Err(OrError).or(Ok(5000)).get()
expected = Ok(5000),
actual = Err(OrError).or(Ok(5000))
)
}
}
@ -29,21 +30,22 @@ class OrTest {
@Test
fun returnsValueIfOk() {
assertEquals(
expected = 3000,
actual = Ok(3000).orElse { Ok(4000) }.get()
expected = Ok(3000),
actual = Ok(3000).orElse { Ok(4000) }
)
}
@Test
fun returnsTransformedValueIfErr() {
assertEquals(
expected = 2000,
actual = Err(4000).orElse { Ok(2000) }.get()
expected = Ok(2000),
actual = Err(4000).orElse { Ok(2000) }
)
}
}
class OrElseThrow {
@Test
fun returnsValueIfOk() {
assertEquals(
@ -53,18 +55,14 @@ class OrTest {
}
@Test
fun returnsTransformedValueIfErr() {
val error = RuntimeException("or else throw")
fun provideError(): Result<String, Throwable> {
return Err(error)
}
assertFailsWith<RuntimeException>(error.message, provideError()::orElseThrow)
fun throwsErrorIfErr() {
val result = Err(RuntimeException("or else throw"))
assertFailsWith<RuntimeException>(block = result::orElseThrow)
}
}
class ThrowIf {
@Test
fun returnsValueIfOk() {
assertEquals(
@ -75,25 +73,26 @@ class OrTest {
@Test
fun returnsErrIfPredicateDoesNotMatch() {
val error = RuntimeException("throw if")
val result: Result<Int, Exception> = Err(RuntimeException("throw if"))
assertEquals(
expected = Err(error),
actual = Err(error).throwIf { false }
expected = result,
actual = result.throwIf { false }
)
}
@Test
fun throwsErrIfPredicateMatches() {
val error = RuntimeException("throw if")
val result = Err(RuntimeException("throw if"))
assertFailsWith<RuntimeException>(error.message) {
Err(error).throwIf { true }
assertFailsWith<RuntimeException> {
result.throwIf { true }
}
}
}
class ThrowUnless {
@Test
fun returnsValueIfOk() {
assertEquals(
@ -104,20 +103,20 @@ class OrTest {
@Test
fun returnsErrIfPredicateMatches() {
val error = RuntimeException("example")
val result: Result<Int, Exception> = Err(RuntimeException("throw unless"))
assertEquals(
expected = Err(error),
actual = Err(error).throwUnless { true }
expected = result,
actual = result.throwUnless { true }
)
}
@Test
fun throwsErrIfPredicateDoesNotMatch() {
val error = RuntimeException("throw unless")
val result = Err(RuntimeException("throw unless"))
assertFailsWith<RuntimeException>(error.message) {
Err(error).throwUnless { false }
assertFailsWith<RuntimeException> {
result.throwUnless { false }
}
}
}

59
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/RecoverTest.kt
View File

@ -7,11 +7,12 @@ class RecoverTest {
private object RecoverError
class Recover {
@Test
fun returnsValueIfOk() {
assertEquals(
expected = Ok(3000),
actual = Ok(3000).recover { 4000 }
actual = Ok(3000).recover { 4000 },
)
}
@ -19,17 +20,18 @@ class RecoverTest {
fun returnsTransformedValueIfErr() {
assertEquals(
expected = Ok(2000),
actual = Err(4000).recover { 2000 }
actual = Err(4000).recover { 2000 },
)
}
}
class RecoverCatching {
@Test
fun returnsValueIfOk() {
assertEquals(
expected = Ok(3000),
actual = Ok(3000).recoverCatching { 4000 }
actual = Ok(3000).recoverCatching { 4000 },
)
}
@ -37,7 +39,7 @@ class RecoverTest {
fun returnsTransformedValueIfErr() {
assertEquals(
expected = Ok(2000),
actual = Err(4000).recoverCatching { 2000 }
actual = Err(4000).recoverCatching { 2000 },
)
}
@ -46,15 +48,14 @@ class RecoverTest {
val exception = IllegalArgumentException("throw me")
assertEquals(
expected = exception,
actual = Err(4000)
.recoverCatching { throw exception }
.getError()
expected = Err(exception),
actual = Err(4000).recoverCatching { throw exception },
)
}
}
class RecoverIf {
@Test
fun returnsValueIfOk() {
fun predicate(int: Int): Boolean {
@ -63,7 +64,7 @@ class RecoverTest {
assertEquals(
expected = Ok(3000),
actual = Ok(3000).recoverIf(::predicate) { 2000 }
actual = Ok(3000).recoverIf(::predicate) { 2000 },
)
}
@ -75,7 +76,7 @@ class RecoverTest {
assertEquals(
expected = Ok(2000),
actual = Err(4000).recoverIf(::predicate) { 2000 }
actual = Err(4000).recoverIf(::predicate) { 2000 },
)
}
@ -87,7 +88,7 @@ class RecoverTest {
assertEquals(
expected = Err(4000),
actual = Err(4000).recoverIf(::predicate) { 2000 }
actual = Err(4000).recoverIf(::predicate) { 2000 },
)
}
@ -99,12 +100,13 @@ class RecoverTest {
assertEquals(
expected = Err(4000),
actual = Err(4000).recoverIf(::predicate) { 2000 }
actual = Err(4000).recoverIf(::predicate) { 2000 },
)
}
}
class RecoverUnless {
@Test
fun returnsValueIfOk() {
fun predicate(int: Int): Boolean {
@ -113,7 +115,7 @@ class RecoverTest {
assertEquals(
expected = Ok(3000),
actual = Ok(3000).recoverUnless(::predicate) { 2000 }
actual = Ok(3000).recoverUnless(::predicate) { 2000 },
)
}
@ -125,7 +127,7 @@ class RecoverTest {
assertEquals(
expected = Ok(2000),
actual = Err(4000).recoverUnless(::predicate) { 2000 }
actual = Err(4000).recoverUnless(::predicate) { 2000 },
)
}
@ -137,7 +139,7 @@ class RecoverTest {
assertEquals(
expected = Err(4000),
actual = Err(4000).recoverUnless(::predicate) { 2000 }
actual = Err(4000).recoverUnless(::predicate) { 2000 },
)
}
@ -149,25 +151,26 @@ class RecoverTest {
assertEquals(
expected = Err(4000),
actual = Err(4000).recoverUnless(::predicate) { 2000 }
actual = Err(4000).recoverUnless(::predicate) { 2000 },
)
}
}
class AndThenRecover {
@Test
fun returnsValueIfOk() {
assertEquals(
expected = 5,
actual = Ok(5).andThenRecover { Ok(7) }.get()
expected = Ok(5),
actual = Ok(5).andThenRecover { Ok(7) },
)
}
@Test
fun returnsTransformValueIfErr() {
assertEquals(
expected = 20,
actual = Err(RecoverError).andThenRecover { Ok(20) }.get()
expected = Ok(20),
actual = Err(RecoverError).andThenRecover { Ok(20) },
)
}
}
@ -181,7 +184,7 @@ class RecoverTest {
assertEquals(
expected = Ok(3000),
actual = Ok(3000).andThenRecoverIf(::predicate) { Ok(2000) }
actual = Ok(3000).andThenRecoverIf(::predicate) { Ok(2000) },
)
}
@ -193,7 +196,7 @@ class RecoverTest {
assertEquals(
expected = Ok(2000),
actual = Err(4000).andThenRecoverIf(::predicate) { Ok(2000) }
actual = Err(4000).andThenRecoverIf(::predicate) { Ok(2000) },
)
}
@ -205,7 +208,7 @@ class RecoverTest {
assertEquals(
expected = Err(2000),
actual = Err(4000).andThenRecoverIf(::predicate) { Err(2000) }
actual = Err(4000).andThenRecoverIf(::predicate) { Err(2000) },
)
}
@ -217,7 +220,7 @@ class RecoverTest {
assertEquals(
expected = Err(4000),
actual = Err(4000).andThenRecoverIf(::predicate) { Ok(2000) }
actual = Err(4000).andThenRecoverIf(::predicate) { Ok(2000) },
)
}
}
@ -231,7 +234,7 @@ class RecoverTest {
assertEquals(
expected = Ok(3000),
actual = Ok(3000).andThenRecoverUnless(::predicate) { Ok(2000) }
actual = Ok(3000).andThenRecoverUnless(::predicate) { Ok(2000) },
)
}
@ -243,7 +246,7 @@ class RecoverTest {
assertEquals(
expected = Ok(2000),
actual = Err(4000).andThenRecoverUnless(::predicate) { Ok(2000) }
actual = Err(4000).andThenRecoverUnless(::predicate) { Ok(2000) },
)
}
@ -255,7 +258,7 @@ class RecoverTest {
assertEquals(
expected = Err(2000),
actual = Err(4000).andThenRecoverUnless(::predicate) { Err(2000) }
actual = Err(4000).andThenRecoverUnless(::predicate) { Err(2000) },
)
}
@ -267,7 +270,7 @@ class RecoverTest {
assertEquals(
expected = Err(4000),
actual = Err(4000).andThenRecoverUnless(::predicate) { Ok(2000) }
actual = Err(4000).andThenRecoverUnless(::predicate) { Ok(2000) },
)
}
}

31
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/ResultIteratorTest.kt
View File

@ -7,28 +7,35 @@ import kotlin.test.assertFalse
import kotlin.test.assertTrue
class ResultIteratorTest {
class HasNext {
@Test
fun returnsTrueIfUnyieldedAndOk() {
val iterator = Ok("hello").iterator()
assertTrue { iterator.hasNext() }
assertTrue(iterator.hasNext())
}
@Test
fun returnsFalseIfErr() {
val iterator = Err("hello").iterator()
assertFalse { iterator.hasNext() }
assertFalse(iterator.hasNext())
}
@Test
fun returnsFalseIfYielded() {
val iterator = Ok("hello").iterator()
iterator.next()
assertFalse { iterator.hasNext() }
assertFalse(iterator.hasNext())
}
}
class Next {
@Test
fun returnsValueIfUnyieldedAndOk() {
assertEquals(
@ -42,7 +49,6 @@ class ResultIteratorTest {
val iterator = Err("hello").iterator()
assertFailsWith<NoSuchElementException> {
@Suppress("IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION")
iterator.next()
}
}
@ -50,24 +56,35 @@ class ResultIteratorTest {
@Test
fun throwsExceptionIfYieldedAndOk() {
val iterator = Ok("hello").iterator()
iterator.next()
assertFailsWith<NoSuchElementException> { iterator.next() }
assertFailsWith<NoSuchElementException> {
iterator.next()
}
}
}
class Remove {
@Test
fun makesHasNextReturnFalse() {
val iterator = Ok("hello").mutableIterator()
iterator.remove()
assertFalse { iterator.hasNext() }
assertFalse(iterator.hasNext())
}
@Test
fun makesNextThrowException() {
val iterator = Ok("hello").mutableIterator()
iterator.remove()
assertFailsWith<NoSuchElementException> { iterator.next() }
assertFailsWith<NoSuchElementException> {
iterator.next()
}
}
}
}

23
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/UnwrapTest.kt
View File

@ -10,25 +10,25 @@ class UnwrapTest {
fun returnsValueIfOk() {
assertEquals(
expected = 5000,
actual = Ok(5000).unwrap()
actual = Ok(5000).unwrap(),
)
}
@Test
fun throwsExceptionIfErr() {
assertFailsWith<UnwrapException>("called Result.unwrap on an Err value 5000") {
@Suppress("IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION")
assertFailsWith<UnwrapException> {
Err(5000).unwrap()
}
}
}
class Expect {
@Test
fun returnsValueIfOk() {
assertEquals(
expected = 1994,
actual = Ok(1994).expect { "the year should be" }
actual = Ok(1994).expect { "the year should be" },
)
}
@ -38,18 +38,17 @@ class UnwrapTest {
override fun toString() = "the year should be"
}
assertFailsWith<UnwrapException>("the year should be 1994") {
@Suppress("IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION")
assertFailsWith<UnwrapException> {
Err(1994).expect { message }
}
}
}
class UnwrapError {
@Test
fun throwsExceptionIfOk() {
assertFailsWith<UnwrapException>("called Result.unwrapError on an Ok value example") {
@Suppress("IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION")
assertFailsWith<UnwrapException> {
Ok("example").unwrapError()
}
}
@ -58,20 +57,20 @@ class UnwrapTest {
fun returnsErrorIfErr() {
assertEquals(
expected = "example",
actual = Err("example").unwrapError()
actual = Err("example").unwrapError(),
)
}
}
class ExpectError {
@Test
fun throwsExceptionIfOk() {
val message = object {
override fun toString() = "the year should be"
}
assertFailsWith<UnwrapException>("the year should be 2010") {
@Suppress("IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION")
assertFailsWith<UnwrapException> {
Ok(2010).expectError { message }
}
}
@ -80,7 +79,7 @@ class UnwrapTest {
fun returnsErrorIfErr() {
assertEquals(
expected = 2010,
actual = Err(2010).expectError { "the year should be" }
actual = Err(2010).expectError { "the year should be" },
)
}
}

116
kotlin-result/src/commonTest/kotlin/com/github/michaelbull/result/ZipTest.kt
View File

@ -20,14 +20,12 @@ class ZipTest {
val result = zip(
{ Ok(10) },
{ Ok(20) },
Int::plus
Int::plus,
)
result as Ok
assertEquals(
expected = 30,
actual = result.value
expected = Ok(30),
actual = result,
)
}
@ -36,14 +34,12 @@ class ZipTest {
val result = zip(
{ Ok(10) },
{ produce(20, "hello") },
Int::plus
Int::plus,
)
result as Err
assertEquals(
expected = "hello",
actual = result.error
expected = Err("hello"),
actual = result,
)
}
@ -52,14 +48,12 @@ class ZipTest {
val result = zip(
{ produce(10, "foo") },
{ produce(20, "bar") },
Int::plus
Int::plus,
)
result as Err
assertEquals(
expected = "foo",
actual = result.error
expected = Err("foo"),
actual = result,
)
}
@ -69,14 +63,12 @@ class ZipTest {
{ Ok("hello") },
{ Ok(2) },
{ Ok(false) },
::ZipData3
::ZipData3,
)
result as Ok
assertEquals(
expected = ZipData3("hello", 2, false),
actual = result.value
expected = Ok(ZipData3("hello", 2, false)),
actual = result,
)
}
@ -86,14 +78,12 @@ class ZipTest {
{ Ok("foo") },
{ Ok(1).and(Err("bar")) },
{ Ok(false) },
::ZipData3
::ZipData3,
)
result as Err
assertEquals(
expected = "bar",
actual = result.error
expected = Err("bar"),
actual = result,
)
}
@ -103,12 +93,12 @@ class ZipTest {
{ Ok("foo") },
{ Ok(1).and(Err("bar")) },
{ Ok(false).and(Err("baz")) },
::ZipData3
::ZipData3,
)
assertEquals(
expected = "bar",
actual = result.getError()
expected = Err("bar"),
actual = result,
)
}
@ -118,14 +108,12 @@ class ZipTest {
{ Ok("foo").and(Err(1)) },
{ Ok(1).and(Err(2)) },
{ Ok(false).and(Err(3)) },
::ZipData3
::ZipData3,
)
result as Err
assertEquals(
expected = 1,
actual = result.error
expected = Err(1),
actual = result,
)
}
@ -136,14 +124,12 @@ class ZipTest {
{ Ok(2) },
{ Ok(false) },
{ Ok(1.5) },
::ZipData4
::ZipData4,
)
result as Ok
assertEquals(
expected = ZipData4("hello", 2, false, 1.5),
actual = result.value
expected = Ok(ZipData4("hello", 2, false, 1.5)),
actual = result
)
}
@ -154,14 +140,12 @@ class ZipTest {
{ Ok(2).and(Err(1)) },
{ Ok(false) },
{ Ok(1.5).and(Err(2)) },
::ZipData4
::ZipData4,
)
result as Err
assertEquals(
expected = 1,
actual = result.error
expected = Err(1),
actual = result,
)
}
@ -173,14 +157,12 @@ class ZipTest {
{ Ok(false) },
{ Ok(1.5) },
{ Ok('a') },
::ZipData5
::ZipData5,
)
result as Ok
assertEquals(
expected = ZipData5("hello", 2, false, 1.5, 'a'),
actual = result.value
expected = Ok(ZipData5("hello", 2, false, 1.5, 'a')),
actual = result,
)
}
@ -192,14 +174,12 @@ class ZipTest {
{ Ok(false) },
{ Ok(1.5) },
{ Ok('a').and(Err(2)) },
::ZipData5
::ZipData5,
)
result as Err
assertEquals(
expected = 1,
actual = result.error
expected = Err(1),
actual = result,
)
}
}
@ -218,11 +198,9 @@ class ZipTest {
a + b + c + d + e
}
result as Ok
assertEquals(
expected = 150,
actual = result.value,
expected = Ok(150),
actual = result,
)
}
@ -238,17 +216,17 @@ class ZipTest {
a + b + c + d + e
}
result as Err
val errors = listOf(
"error one",
"error two",
"error three",
"error four",
"error five",
)
assertEquals(
expected = listOf(
"error one",
"error two",
"error three",
"error four",
"error five",
),
actual = result.error,
expected = Err(errors),
actual = result,
)
}
@ -264,11 +242,9 @@ class ZipTest {
a + b + c + d + e
}
result as Err
assertEquals(
expected = listOf("only error"),
actual = result.error,
expected = Err(listOf("only error")),
actual = result,
)
}
}