Comparación de los marcos de prueba de la unidad C ++ [cerrado]

Sé que ya hay algunas preguntas con respecto a las recomendaciones para los marcos de prueba de la unidad C ++, pero todas las respuestas no ayudaron, ya que solo recomiendan uno de los marcos pero no proporcionan ninguna información sobre una comparación (característica).

Creo que los marcos más interesantes son CppUnit, Boost y el nuevo marco de prueba de Google. ¿Alguien ha hecho alguna comparación todavía?

Vea esta pregunta para alguna discusión.

Recomiendan los artículos: Explorando el marco de pruebas de la unidad C ++ Jungle , por Noel Llopis. Y lo más reciente: marcos de unidades de prueba de C ++

Todavía no he encontrado un artículo que compare googletest con los otros marcos.

Un nuevo reproductor es Google Test (también conocido como Google C ++ Testing Framework ), que es bastante bueno.

#include <gtest/gtest.h>

TEST(MyTestSuitName, MyTestCaseName) {
    int actual = 1;
    EXPECT_GT(actual, 0);
    EXPECT_EQ(1, actual) << "Should be equal to one";
}

Principales características:

• Portátil
• Afirmaciones fatales y no fatales
• Fácil afirmaciones mensajes informativos :ASSERT_EQ(5, Foo(i)) << " where i = " << i;
• Google Test detecta automáticamente sus pruebas y no requiere que las enumere para ejecutarlas
• Haz que sea fácil ampliar su vocabulario de afirmación
• Pruebas de muerte (ver guía avanzada)
• SCOPED_TRACE para bucles de subrutina
• Tu puedes decidir qué pruebas ejecutar
• Generación de informes de prueba XML
• Accesorios / simulacro / plantillas ...

Acabo de empujar mi propio marco, CATCH , por ahí. Todavía está en desarrollo, pero creo que ya supera la mayoría de los otros marcos. Diferentes personas tienen diferentes criterios, pero he tratado de cubrir la mayoría del terreno sin demasiadas compensaciones. Echa un vistazo a mi entrada de blog vinculada para un catador. Mis cinco características principales son:

• Solo encabezado
• Registro automático de pruebas basadas en funciones y métodos.
• Descompone expresiones C ++ estándar en LHS y RHS (por lo que no necesita una familia completa de macros de aserción).
• Soporte para secciones anidadas dentro de un dispositivo basado en funciones
• Pruebas de nombres utilizando lenguaje natural: se generan nombres de funciones / métodos

También tiene enlaces Objective-C. El proyecto está alojado en Github

Boost Test Library es una muy buena opción, especialmente si ya está usando Boost.

// TODO: Include your class to test here.
#define BOOST_TEST_MODULE MyTest
#include <boost/test/unit_test.hpp>

BOOST_AUTO_TEST_CASE(MyTestCase)
{
    // To simplify this example test, let's suppose we'll test 'float'.
    // Some test are stupid, but all should pass.
    float x = 9.5f;

    BOOST_CHECK(x != 0.0f);
    BOOST_CHECK_EQUAL((int)x, 9);
    BOOST_CHECK_CLOSE(x, 9.5f, 0.0001f); // Checks differ no more then 0.0001%
}

Soporta:

• Registro de pruebas automáticas o manuales.
• Muchas afirmaciones
• Comparación automática de colecciones
• Varios formatos de salida (incluido XML )
• Accesorios / Plantillas ...

PD: Escribí un artículo al respecto que puede ayudarlo a comenzar: Marco de prueba de unidad C ++: un tutorial de prueba de refuerzo

Wikipedia tiene una lista completa de marcos de prueba de unidad , con tablas que identifican características compatibles o no.

Recientemente lancé xUnit ++ , específicamente como una alternativa a Google Test y Boost Test Library (ver las comparaciones ). Si está familiarizado con xUnit.Net, está listo para xUnit ++.

#include "xUnit++/xUnit++.h"

FACT("Foo and Blah should always return the same value")
{
    Check.Equal("0", Foo()) << "Calling Foo() with no parameters should always return \"0\".";
    Assert.Equal(Foo(), Blah());
}

THEORY("Foo should return the same value it was given, converted to string", (int input, std::string expected),
    std::make_tuple(0, "0"),
    std::make_tuple(1, "1"),
    std::make_tuple(2, "2"))
{
    Assert.Equal(expected, Foo(input));
}

Principales características:

• Increíblemente rápido: las pruebas se ejecutan simultáneamente .
• Portátil
• Registro automático de prueba
• Muchos tipos de aserciones (Boost no tiene nada en xUnit ++)
• Compara colecciones forma nativa.
• Las aserciones entran tres niveles:
  • Errores fatales
  • errores no fatales
  • advertencias
• Registro de afirmación fácil :Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
• PruebaRegistro de :Log.Debug << "Starting test"; Log.Warn << "Here's a warning";
• Accesorios
• Basado en datosPruebas (teorías)
• Seleccione qué pruebas ejecutar función de:
  • Atributo de coincidencia
  • Nombre de subcadena matchin
  • Suites de prueba

CppUTest : marco muy agradable y ligero con bibliotecas simuladas. Vale la pena echar un vistazo más de cerca.

CPUnit ( http://cpunit.sourceforge.net ) es un marco que es similar a Google Test, pero que se basa en menos macos (las afirmaciones son funciones) y donde las macros tienen el prefijo para evitar el error macro habitual. Las pruebas se ven así:

#include <cpunit>

namespace MyAssetTest {
    using namespace cpunit;

    CPUNIT_FUNC(MyAssetTest, test_stuff) {
        int some_value = 42;
        assert_equals("Wrong value!", 666, some_value);
    }

    // Fixtures go as follows:
    CPUNIT_SET_UP(MyAssetTest) {
        // Setting up suite here...
        // And the same goes for tear-down.
    }

}

Se registran automáticamente, por lo que no necesita más que esto. Entonces es solo compilar y ejecutar. Creo que usar este marco es muy parecido a usar JUnit, para aquellos que han tenido que pasar algún tiempo programando Java. ¡Muy agradable!

Hay algunos recursos de prueba de unidad C ++ relevantes en http://www.progweap.com/resources.html

API Sanity Checker : marco de prueba para bibliotecas C / C ++:

Un generador automático de pruebas unitarias básicas para una biblioteca compartida C / C ++. Es capaz de generar datos de entrada razonables (en la mayoría, pero desafortunadamente no todos los casos) para parámetros y componer casos de prueba simples ("sanidad" o "calidad superficial") para cada función en la API a través del análisis de declaraciones en el encabezado archivos.

La calidad de las pruebas generadas permite verificar la ausencia de errores críticos en casos de uso simples. La herramienta es capaz de construir y ejecutar pruebas generadas y detectar fallas (segfaults), abortos, todo tipo de señales emitidas, código de retorno de programa distinto de cero y programa suspendido.

Características únicas en comparación con CppUnit, Boost y Google Test:

• Generación automática de datos de prueba y argumentos de entrada (incluso para tipos de datos complejos)
• Tipos especializados modernos y altamente reutilizables en lugar de accesorios y plantillas