cargo test es la herramienta fundamental para garantizar la integridad del software en Rust. Su funcionamiento se divide en tres capas: los unit tests (pruebas unitarias dentro de los módulos de código), los integration tests (pruebas que residen en la carpeta tests/ y validan la API pública como un usuario externo) y los doctests (ejemplos de código integrados en la documentación técnica mediante comentarios ///). Para un flujo de trabajo eficiente, es vital utilizar el flag --nocapture cuando se desea ver la salida de println! durante una prueba, o filtrar tests específicos usando cargo test <nombre_del_test> para evitar ejecutar la suite completa.

cargo bench se utiliza para realizar mediciones de rendimiento. En el canal nightly de Rust, se puede utilizar el atributo #[bench] para pruebas estandarizadas; sin embargo, en el canal stable (el más común), la práctica recomendada es realizar mediciones manuales utilizando std::time::Instant para capturar el tiempo transcurrido con alta precisión.

cargo doc es el motor de documentación de Rust. Genera archivos HTML profesionales a partir de los comentarios de tus módulos. Para optimizar el tiempo de generación en proyectos grandes, se utiliza --no-deps para no procesar la documentación de todas las librerías externas, y --document-private-items si se necesita generar documentación para elementos que no son públicos, lo cual es útil para auditorías internas antes de publicar un crate.

//! Ejemplo integral de herramientas de Cargo: Tests, Benchmarks y Documentación.

/// Suma dos números enteros.
///
/// # Examples
///

/// use example::sumar;
/// // El doctest valida que el código en los comentarios sea correcto.
/// assert_eq!(sumar(2, 3), 5);
/// 

pub fn sumar(a: i32, b: i32) -> i32 {
    a + b
}

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

    #[test]
    fn test_sumar_positivo() {
        // Test unitario estándar para verificar la lógica de sumar.
        assert_eq!(sumar(10, 20), 30);
    }

    #[test]
    fn test_sumar_con_log() {
        // Para ver este println, ejecutar: cargo test -- --nocapture
        let resultado = sumar(5, 5);
        println!("Debug: El resultado de sumar 5 + 5 es: {}", resultado);
        assert_eq!(resultado, 10);
    }
}

/// Función para medir el rendimiento de forma manual (estilo cargo bench en stable).
pub fn medir_rendimiento() {
    let inicio = std::time::Instant::now();
    
    // Ejecutamos la función varias veces para observar el tiempo
    let _res = sumar(1000, 2000);
    
    let duracion = inicio.elapsed();
    println!("Tiempo de ejecución medido: {:?}", duracion);
}

fn main() {
    println!("Iniciando aplicación de ejemplo...");
    medir_rendimiento();
}

Análisis del Código

  • sumar(a: i32, b: i32) -> i32: Es una función pública que recibe dos parámetros de tipo i32 y devuelve un i32. Su documentación incluye un bloque de código en el formato de doctest, asegurando que los ejemplos de la documentación sean funcionalmente correctos.
  • test_sumar_positivo: Un test unitario estándar que utiliza assert_eq! para validar que la función sumar devuelva el valor esperado.
  • test_sumar_con_log: Este test demuestra el uso de la consola. Al ejecutar cargo test -- --nocapture, la variable resultado (de tipo i32) imprimirá su valor mediante println!, permitiendo la depuración visual.
  • medir_rendimiento: Implementa una medición de rendimiento manual. Utiliza std::time::Instant::now() para capturar el tiempo inicial y inicio.elapsed() para calcular la duración tras la ejecución de sumar. El resultado se imprime usando el tipo Duration mediante println!.
  • main: Punto de entrada que invoca a medir_rendimiento para demostrar la ejecución del código de medición.

N° 79