Kotlin Academy · Aula

Asserções

Verifique o comportamento

Asserções é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

O que é uma asserção?

Uma asserção verifica se um valor real corresponde ao que você espera. Se ela falhar, o teste falha com uma mensagem útil.

O JUnit5 fornece asserções em org.junit.jupiter.api.Assertions.

assertEquals

A asserção mais comum. Observe a ordem: valor esperado primeiro, valor real depois.

import org.junit.jupiter.api.Assertions.assertEquals

fun main() {
    val sum = 2 + 3
    assertEquals(5, sum)
    println("passed")
}

assertTrue e assertFalse

Verifique diretamente as condições booleanas.

import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Assertions.assertFalse

fun main() {
    assertTrue(10 > 5)
    assertFalse("".isNotEmpty())
    println("ok")
}

Asserções de nulidade

Use assertNull e assertNotNull para verificar a possibilidade de nulos. assertNotNull também faz conversões inteligentes de tipo em muitos casos.

import org.junit.jupiter.api.Assertions.assertNotNull
import org.junit.jupiter.api.Assertions.assertNull

fun main() {
    val name: String? = "Ada"
    assertNotNull(name)
    assertNull(null)
    println("done")
}

Verificando exceções

assertThrows verifica se um bloco lança uma exceção específica. Ele retorna a exceção para que você possa inspecionar a mensagem dela.

import org.junit.jupiter.api.Assertions.assertThrows
import org.junit.jupiter.api.Assertions.assertEquals

fun main() {
    val ex = assertThrows(IllegalArgumentException::class.java) {
        require(false) { "bad input" }
    }
    assertEquals("bad input", ex.message)
    println("caught")
}

Asserções agrupadas

assertAll executa várias asserções e relata todas as falhas juntas, em vez de parar na primeira.

import org.junit.jupiter.api.Assertions.assertAll
import org.junit.jupiter.api.Assertions.assertEquals

fun main() {
    assertAll(
        { assertEquals(2, 1 + 1) },
        { assertEquals(4, 2 + 2) }
    )
    println("all passed")
}

Mensagens de falha

Passe uma mensagem (ou uma lambda de mensagem avaliada sob demanda) para tornar as falhas autoexplicativas.

import org.junit.jupiter.api.Assertions.assertEquals

fun main() {
    val balance = 100
    assertEquals(100, balance, "balance should be unchanged")
    println("ok")
}

Comparando coleções

assertEquals funciona para listas quando a ordem e o conteúdo correspondem. Use assertIterableEquals para iteráveis de tipos concretos diferentes.

import org.junit.jupiter.api.Assertions.assertEquals

fun main() {
    val expected = listOf(1, 2, 3)
    val actual = (1..3).toList()
    assertEquals(expected, actual)
    println("lists equal")
}

Asserções encadeadas com AssertK

Bibliotecas como o AssertK oferecem um estilo legível de assertThat(x).isEqualTo(y), popular em bases de código Kotlin.

// assertThat(result).isEqualTo(5)
// assertThat(list).contains("a", "b")
// assertThat(name).isNotNull()

Forçando uma falha

Chame fail para forçar uma falha, o que é útil para marcar ramificações inalcançáveis ou testes inacabados.

import org.junit.jupiter.api.Assertions.fail

fun process(x: Int): String = when {
    x > 0 -> "positive"
    else -> fail("unexpected value")
}

Escolhendo a asserção correta

Escolha a asserção mais específica para obter falhas claras:

Igualdade → assertEquals
Condições → assertTrue/assertFalse
Erros → assertThrows
Várias verificações → assertAll

Verificação rápida

Você quer que um teste relate todas as verificações que falharam de uma vez, em vez de parar na primeira. O que deve usar?

Recapitulação

Agora você conhece as asserções do JUnit5:

assertEquals (valor esperado primeiro), assertTrue/assertFalse
assertNull/assertNotNull, assertThrows
assertAll para verificações agrupadas
Adicione mensagens para obter mais clareza

A seguir: simulando dependências com MockK.

Perguntas Frequentes

A aula “Asserções” é grátis?

Sim — o texto completo de “Asserções” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Asserções”?

Verifique o comportamento Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Asserções”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kotlin Academy