Comparação de frameworks de ensaio unit C++ [fechados]

Um novo jogador é Google Test (também conhecido como Google C++ Testing Framework), o que é muito bom.

#include <gtest/gtest.h>

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

Principais características:

• Portátil
• fatais e afirmações não fatais
Mensagens informativas : ASSERT_EQ(5, Foo(i)) << " where i = " << i;
• O Google Test detecta automaticamente os seus testes e não exige que os enumere para os Executar
Faz com que seja fácil amplia o teu vocabulário de asserção
• testes de morte (ver guia Avançado)
• SCOPED_TRACE para loops subrotinos
• pode decidir quais os testes a executar
• XML geração do relatório de ensaio
• Material Fixo / Gozar / Templates ...

• apenas o cabeçalho
• registo automático das funções e dos ensaios baseados em métodos
• decompõe expressões C++ padrão em LHS e RHS (então você não precisa de uma família inteira de asserções macros).
• Suporte para secções aninhadas dentro de um suporte baseado em funções
• são gerados testes de nomes utilizando linguagem natural-funções / métodos

Também tem ligações objectivo-C. O projeto está hospedado em Github

Biblioteca de testes de impulso é uma escolha muito boa, especialmente se você já está usando impulso.

// 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%
}

Suporta:

• registo automático ou de ensaios manuais
• muitas afirmações
• comparação automática das colecções
• vários formatos de saída (incluindo XML)
• Material Fixo / Templates ...

A Wikipédia tem uma lista exaustiva de quadros de ensaio de unidades, com tabelas que identificam as funcionalidades suportadas ou não.

Publiquei recentemente xUnit++, especificamente como uma alternativa ao teste do Google e à biblioteca de testes Boost (veja as comparações ). Se estiver familiarizado com xUnit.Net estás pronto para o 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));
}

Principais características:

• incrivelmente rápido: os testes corremconcomitantemente .
• Portátil
• registo automático
• muitos tipos de afirmação (o impulso não tem nada sobre xUnit++)
• compara colecções nativamente.
• As afirmações vêm em três níveis :
  • erros fatais
  • erros não fatais
  • advertências
• fácil afirmar Registo: Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
• Teste Registo: Log.Debug << "Starting test"; Log.Warn << "Here's a warning";
• material fixo
• a base de Dados testes (teorias)
• Seleccione com base nos testes a executar :
  • correspondência de atributos
  • nome Matchin substring
  • Conjuntos De Teste

CppUTest - Muito bom, framework light weight com bibliotecas simuladas. Vale a pena olhar mais de perto.

CPUnit (http://cpunit.sourceforge.net) é um framework que é semelhante ao Google Teste, mas que depende menos do macos (afirma são funções), e onde as macros são prefixados para evitar a habitual macro armadilha. Os testes parecem:

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

}

Existem alguns recursos de ensaio de unidades c++ relevantes em http://www.progweap.com/resources.html

API Sanity Checker - test framework for C / C++ libraries:

Um gerador automático de testes unitários básicos para uma biblioteca C/C++ partilhada. Ele é capaz de gerar dados de entrada razoáveis (na maioria dos casos, mas infelizmente não todos) para parâmetros e compor casos de teste simples ("sanidade" ou "qualidade superficial") para cada função na API através da análise de declarações em arquivos de cabeçalho.

A qualidade dos testes gerados permite verificar a ausência de erros críticos em casos de uso simples. A ferramenta é capaz de construir e executar testes gerados e detectar quebras (segfaults), abortar, todos os tipos de sinais emitidos, código de retorno de programa não-zero e suspensão de programa.

Características únicas em comparação com CppUnit, Boost e Teste Google:

• geração automática de dados de ensaio e argumentos de entrada (mesmo para tipos de dados complexos)
• modernos e altamente reutilizáveis tipos especializados em vez de fixações e modelos