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

StackOverflow https://stackoverflow.com/questions/242926

Pregunta

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?

¿Fue útil?

Solución

Ver 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 la unidad de prueba C ++

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

Otros consejos

Un nuevo jugador es Google Test (también conocido como Marco de pruebas de Google C ++ ) que es bastante agradable. 

#include <gtest/gtest.h>

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

Características principales:

  • Portátil
  • Afirmaciones fatales y no fatales
  • Aserciones fáciles de mensajes informativos : ASSERT_EQ(5, Foo(i)) << " where i = " << i;
  • Google Test automáticamente detecta sus pruebas y no requiere que las enumere para ejecutarlas
  • Facilite extender su vocabulario de afirmaciones
  • Pruebas de muerte (consulte la guía avanzada)
  • SCOPED_TRACE para bucles de subrutina
  • Puede decidir qué pruebas ejecutar
  • XML generación de informes de prueba
  • Fixtures / Mock / Plantillas ...

Acabo de insertar 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 nombre usando lenguaje natural - se generan nombres de función / método

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á utilizando 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 automático de pruebas o manuales
  • Muchas afirmaciones
  • Comparación automática de colecciones
  • Varios formatos de salida (incluido XML )
  • Fixtures / Plantillas ...

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

Wikipedia tiene una completa lista de marcos de pruebas unitarias , 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 el 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));
}

Características principales:

  • Increíblemente rápido: las pruebas se ejecutan simultáneamente .
  • Portátil
  • Automático registro de prueba
  • Muchos tipos de aserción (Boost no tiene nada en xUnit ++)
  • Compara las colecciones de forma nativa.
  • Las aserciones vienen en tres niveles:
    • errores fatales
    • errores no fatales
    • advertencias
  • Registro fácil de afirmación : Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
  • Prueba registro: Log.Debug << "Starting test"; Log.Warn << "Here's a warning";
  • Accesorios
  • Pruebas basadas en datos (Teorías)
  • Seleccione qué pruebas ejecutar según:
    • Coincidencia de atributos
    • Nombre de subcadena coincidente
    • Conjuntos de pruebas

CppUTest : un 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 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. El uso de este marco me parece muy similar al uso de JUnit, para aquellos que han tenido que pasar algún tiempo programando Java. Muy bien!

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

API Sanity Checker & # 8212; marco de prueba para bibliotecas C / C ++:

  

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

     

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 bloqueo de programa.

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)
  • Modernos y altamente reutilizables tipos especializados en lugar de accesorios y plantillas
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top