calculator-henriquecapi 0.1.0

pub mod calc1;
pub mod calc2;

#[cfg(test)]
mod tests {
    // Importamos todas as funções que vamos testar
    use super::calc1::{add, sub};
    use super::calc2::{multiply, rate};

    // --- Testes para a função add ---
    #[test]
    fn test_add_normal() {
        // Testa uma soma simples que deve funcionar
        assert_eq!(add(2, 2), 4);
    }

    #[test]
    fn test_add_saturating() {
        // Testa se a soma satura no valor máximo de u32 em vez de estourar (overflow)
        assert_eq!(add(u32::MAX, 1), u32::MAX);
    }

    // --- Testes para a função sub ---
    #[test]
    fn test_sub_normal() {
        // Testa uma subtração simples
        assert_eq!(sub(10, 5), 5);
    }

    #[test]
    fn test_sub_underflow_returns_zero() {
        // Testa o caso onde o resultado seria negativo.
        // A função deve retornar 0 para evitar um "underflow".
        assert_eq!(sub(5, 10), 0);
    }

    // --- Testes para a função multiply ---
    #[test]
    fn test_multiply_normal() {
        // Testa uma multiplicação simples
        assert_eq!(multiply(10, 5), 50);
    }

    #[test]
    fn test_multiply_by_zero() {
        // Multiplicar por zero deve sempre resultar em zero
        assert_eq!(multiply(10, 0), 0);
    }

    #[test]
    fn test_multiply_overflow() {
        // Este teste vai falhar inicialmente, pois a multiplicação padrão causa pânico.
        // Ele serve para nos forçar a melhorar a função `multiply`.
        assert_eq!(multiply(u32::MAX, 2), u32::MAX);
    }

    // --- Testes para a função rate (divisão) ---
    #[test]
    fn test_rate_normal() {
        // Testa uma divisão simples
        assert_eq!(rate(10, 2), 5);
    }

    #[test]
    fn test_rate_integer_truncation() {
        // A divisão de inteiros descarta a parte fracionária. 10 / 3 = 3.33..., que vira 3.
        assert_eq!(rate(10, 3), 3);
    }

    #[test]
    fn test_rate_division_by_zero_returns_zero() {
        // A nossa função foi programada para retornar 0 em caso de divisão por zero.
        // Este teste garante que esse comportamento está funcionando.
        assert_eq!(rate(10, 0), 0);
    }
}