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


300

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?



Tengo mi propio marco de pruebas basado en IOC que me gusta más porque no es solo un clon de lo que hacen los demás, sino que aborda lo que creo que son todos los problemas de los demás. Usted escribe casos de prueba derivando de una clase, no usando macros. Las macros solo se usan para afirmaciones, ya que te dan una reflexión. Salida personalizada de estadísticas de prueba. Ejecutar desde scripts IOC para que elija lo que prueba, con qué frecuencia y con qué parámetros.
CashCow

y es brillante desde el punto de vista del desarrollo, ya que cuando agrego mi propia prueba, puedo ejecutarla sin tener que ejecutar las de los demás al mismo tiempo. Entonces sé que mi código está funcionando.
CashCow

Respuestas:


99

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.


Como escribí: todas las respuestas solo recomiendan uno de los marcos pero no comparan el marco con otro.
Housemaister

¿No estás contento con el artículo tampoco?
Gishu

77
Una crítica: el artículo, aunque bueno, es de 2004 y no incluye Google Test.
richq

2
En el primer enlace verás dos comparaciones. Excepto el nuevo marco de google, la mayoría de la información sigue siendo relevante. (Y CppUnit no es lo más interesante, es demasiado torpe para usar)
Luc Hermitte

1
arregló los enlaces y amplió la respuesta con una comparación más reciente
Sam Saffron

120

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 ...

3
Realmente disfruto usando la prueba de Google sobre algunos de los otros marcos, especialmente con sus capacidades de burla que se pueden encontrar en el marco de googlemock.
Mike

8
Proporciono todas estas características (aunque algunas aún no son públicas) y más en mi nuevo marco de prueba, CATCH. Vea mi respuesta para el enlace.
philsquared

2
combinarlo con el marco de simulación de Google C ++ lo convierte en un marco de prueba xUnit realmente potente para el código de prueba unitaria de C ++.
ratkok

55
@CashCow Ejecutar con la compilación es algo diferente de la detección de prueba. Ejecutar con build depende de su sistema de compilación. La detección de prueba significa que no tiene que enumerar todas las pruebas en otra clase, solo cree los métodos de prueba y listo.
Wernight

Sin embargo, no me gusta su uso excesivo de macros y el hecho de que usen palabras comunes como TEST que podrían chocar con algo. GTEST sería mejor, menos probable que choque.
CashCow

112

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


Por favor considere agregar CHECK_FLASEy REQUIRE_FLASEmacros.
Emile Cormier

66
El mejor marco en mi opinión.
CoffeDeveloper

3
doctest es mi reimplementación de Catch con un gran enfoque en la velocidad de compilación - consulte las preguntas frecuentes para ver cómo difieren
onqtam

@einpoklum Catch no se abandona: el creador está trabajando en la versión 2 de la biblioteca. doctest es una especie de reimplementación de Catch 1 con algunas decisiones de diseño adicionales
onqtam

2
Estoy realmente perdido al comparar todos los marcos de prueba (uno de los cuales ahora tengo que elegir). ¿Escribirías tu propia respuesta comparando y contrastando doctest con Catch y otras ofertas?
einpoklum

53

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


Solía ​​usar la prueba Boost y me gustó, excepto que parecía cambiar significativamente entre lanzamientos. Era bastante difícil vender pruebas unitarias a mi cliente sin tener que gastar más de mi tiempo (y su dinero) arreglando las pruebas cuando la API cambió, que arreglar el código que estaba destinado a probar. Al final lo abandoné y escribí el mío, aunque fue hace unos 5 años.
Componente 10

55
El enlace del tutorial está roto
mloskot

2
@mloskot Funciona de nuevo.
Chris Jester-Young

@mloskot Lo siento, por favor envíeme un correo electrónico directamente si ve que está roto. Es fácil de encontrar que un comentario. :)
Wernight

@Wernight Yup, funciona de nuevo. Thx
mloskot


16

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

2
La pregunta es pedir una comparación. En mi opinión, es vital presentar cuáles son las diferencias entre su marco y, al menos, los dos populares: googletest y Boost. Especialmente, si anuncia xUnit ++ como alternativa a esos dos. Será +1 si se actualiza :)
mloskot

Lo suficientemente justo. :) Ya tengo una tabla de comparación en la wiki , pero intentaré resumir algunas de las diferencias directamente en mi respuesta.
moswald

1
Decidí simplemente vincular la tabla wiki directamente, estaba abarrotando el resumen para enumerarlo todo.
moswald

el enlace me funciona, gracias! +1
mloskot

1
ha sido descontinuado su proyecto? La última confirmación se remonta al 09/2015 ... De todos modos, gran respuesta. Gracias.
zertyz


4

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!



2

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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.