Fácil Rust

Testando uma função de multiplicação

Enunciado

Crie uma função multiplica(a: i32, b: i32) -> i32 e escreva um teste unitário que verifique se multiplica(3, 4) retorna 12.

Requisitos

  • A função multiplica deve retornar o produto dos dois argumentos.
  • O teste deve usar assert_eq! para comparar o resultado com o valor esperado.
  • O teste deve estar dentro do módulo tests com #[cfg(test)].

Código inicial

pub fn multiplica(a: i32, b: i32) -> i32 {
    // implemente
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn testa_multiplicacao() {
        // escreva o teste
    }
}

fn main() {
    println!("{}", multiplica(3, 4));
}

Saída esperada

12
Ver dica

Use a * b para multiplicar e assert_eq!(multiplica(3, 4), 12) no teste.

Mostrar solução 
pub fn multiplica(a: i32, b: i32) -> i32 {
    a * b // retorna o produto
}

#[cfg(test)]
mod tests {
    use super::*; // importa a função do módulo pai

    #[test]
    fn testa_multiplicacao() {
        assert_eq!(multiplica(3, 4), 12); // verifica se 3 * 4 = 12
    }
}

fn main() {
    println!("{}", multiplica(3, 4));
}

Passo a passo

  1. Definimos multiplica que recebe dois i32 e retorna a * b.
  2. O módulo tests é anotado com #[cfg(test)] para ser compilado apenas em testes.
  3. use super::*; traz multiplica para o escopo do teste.
  4. A função de teste é marcada com #[test].
  5. Dentro dela, assert_eq!(multiplica(3, 4), 12) compara o resultado com 12.
  6. Se a comparação falhar, o teste entra em pânico e o cargo test reporta falha.

Por que funciona

O cargo test descobre funções anotadas com #[test] e as executa. assert_eq! verifica igualdade e, em caso de falha, mostra os valores esperado e obtido, facilitando o diagnóstico.

Erros comuns

  • Esquecer use super::*; dentro do módulo tests: o compilador não encontra multiplica.
  • Usar assert! em vez de assert_eq!: funciona, mas a mensagem de erro é menos informativa.
  • Colocar o teste fora do módulo tests sem #[cfg(test)]: o código de teste é compilado no binário final.

Outra forma de resolver

Poderia usar assert!(multiplica(3, 4) == 12), mas assert_eq! é preferível por mostrar os valores na falha.

Saída esperada

12