Comparación de los marcos de prueba de unidad de C ++

Sé que ya hay algunas preguntas con respecto a las recomendaciones para los marcos de prueba de unidad de 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?

Vea esta pregunta para una discusión.

Recomiendan los artículos: Explorando el marco de pruebas unitarias de C ++ Jungle , por Noel Llopis. Y el más reciente: C ++ Test Unit Frameworks

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

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

#include  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
  • Mensajes informativos de aserciones sencillas: ASSERT_EQ(5, Foo(i)) < < " where i = " << i;
  • Google Test detecta automáticamente sus pruebas y no requiere que las enumere para poder ejecutarlas
  • Facilite la extensión de su vocabulario de aseveración
  • Pruebas de muerte (ver guía avanzada)
  • SCOPED_TRACE para bucles de subrutina
  • Puedes decidir qué pruebas ejecutar
  • Generación de informes de prueba XML
  • Fixtures / Mock / Templates ...

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

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

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

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

 // TODO: Include your class to test here. #define BOOST_TEST_MODULE MyTest #include  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% } 

Es compatible con:

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

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

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

Recientemente he lanzado xUnit ++ , específicamente como una alternativa a Google Test y Boost Test Library (vea las comparaciones ). Si está familiarizado con xUnit.Net, ya 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 al mismo tiempo .
  • Portátil
  • Registro de prueba automática
  • Muchos tipos de afirmaciones (Boost no tiene nada en xUnit ++)
  • Compara colecciones de forma nativa.
  • Las afirmaciones vienen en tres niveles:
    • Errores fatales
    • errores no fatales
    • advertencias
  • Assert.Equal(-1, foo(i)) < < "Failed with i = " << i; fácil de Assert.Equal(-1, foo(i)) < < "Failed with i = " << i; : Assert.Equal(-1, foo(i)) < < "Failed with i = " << i;
  • Log.Debug < < "Starting test"; Log.Warn << "Here's a warning"; prueba : Log.Debug < < "Starting test"; Log.Warn << "Here's a warning"; Log.Debug < < "Starting test"; Log.Warn << "Here's a warning";
  • Fixtures
  • Pruebas basadas en datos (Teorías)
  • Seleccione qué pruebas ejecutar en función de:
    • Coincidencia de atributos
    • Nombre subcadena matchin
    • Suites de prueba

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

CPUnit ( http://cpunit.sourceforge.net ) es un marco que es similar al de Google Test, pero que se basa en menos macos (los asertos son funciones), y donde las macros tienen el prefijo para evitar la típica falla macro. Las pruebas se ven así:

 #include  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 comstackr y ejecutar. Me parece que usar este framework es muy parecido a usar JUnit, para aquellos que han tenido que dedicar algún tiempo a progtwigr Java. ¡Muy agradable!

Hay algunos recursos de prueba de unidades de 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 de unidades básicas para una biblioteca C / C ++ compartida. Es capaz de generar datos de entrada razonables (en la mayoría, pero desafortunadamente no todos) para parámetros y redactar casos de prueba simples (“cordura” o “superficial”) para cada función en la API mediante el 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 simple. La herramienta puede construir y ejecutar pruebas generadas y detectar lockings (segfaults), abortos, todo tipo de señales emitidas, código de retorno de progtwig distinto de cero y ejecución de progtwig.

Funciones ú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