Errors and Testing

class Account(initial: Long) {
    var balance = initial
        private set
    private var closed = false

    init {
        require(initial >= 0) { "Initial balance must not be negative: $initial" }
    }

    fun deposit(amount: Long) {
        require(amount > 0) { "Deposit must be positive" }
        check(!closed) { "Account is closed" }
        balance += amount
    }

    fun close() {
        if (closed) error("Account already closed")
        closed = true
    }
}

Messages are passed as lambdas, so the string is only built when the check fails. private set makes the property readable everywhere but writable only inside the class.

runCatching and Result

When failure is common and expected, you can treat it as data instead of throwing. runCatching runs a block and wraps either its value or the caught exception in a Result<T>.

import java.io.File

fun main() {
    val result: Result<String> = runCatching { File("app.conf").readText() }

    result
        .onSuccess { println("Read ${it.length} characters") }
        .onFailure { println("Could not read: ${it.message}") }

    val text = result.getOrElse { "default config" }
    val lineCount = result.map { it.lines().size }.getOrDefault(0)
    println("$text / $lineCount")
}

Result also offers isSuccess, getOrNull, exceptionOrNull and fold. One caveat: runCatching catches every Throwable, so inside coroutines take care not to swallow CancellationException, which is how cancellation is signaled.

Testing with kotlin.test

kotlin.test is a test library with the same API on every platform; on the JVM it runs on top of JUnit. The Gradle setup is short:

// build.gradle.kts
dependencies {
    testImplementation(kotlin("test"))
}

tasks.test {
    useJUnitPlatform()
}

With useJUnitPlatform(), the Kotlin Gradle plugin picks the JUnit 5 flavor of kotlin-test for you. Tests go under src/test/kotlin.

// src/test/kotlin/AccountTest.kt
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith

class AccountTest {
    @Test
    fun `deposit increases the balance`() {
        val account = Account(1_000)
        account.deposit(500)
        assertEquals(1_500L, account.balance)
    }

    @Test
    fun `non-positive deposits are rejected`() {
        val account = Account(0)
        val e = assertFailsWith<IllegalArgumentException> {
            account.deposit(-1)
        }
        assertEquals("Deposit must be positive", e.message)
    }
}

Backtick-quoted function names can be full sentences, which makes test reports easy to read. Run everything with ./gradlew test. Popular additions include Kotest for richer assertions and test styles, MockK for mocking, and runTest from kotlinx-coroutines-test for coroutine code.

Summary

• Kotlin has no checked exceptions: no throws clauses and no forced catch blocks.
• try and throw are expressions, so their results can be assigned or used after the Elvis operator.
• Use require for arguments, check for state, and error for unreachable code.
• runCatching wraps outcomes in Result; avoid swallowing cancellation inside coroutines.
• Write tests with @Test, assertEquals and assertFailsWith from kotlin.test, and run them with ./gradlew test.