Comparação de estruturas de teste de unidade C ++ [fechadas]

Sei que já existem algumas perguntas sobre recomendações para estruturas de teste de unidade C ++, mas todas as respostas não ajudaram, pois apenas recomendam uma das estruturas, mas não fornecem nenhuma informação sobre uma comparação (recurso).

Eu acho que as estruturas mais interessantes são CppUnit, Boost e a nova estrutura de testes do Google. Alguém já fez alguma comparação?

Veja esta pergunta para alguma discussão.

Eles recomendam os artigos: Explorando a selva da estrutura de testes de unidade C ++ , por Noel Llopis. E o mais recente: estruturas de unidades de teste C ++

Ainda não encontrei um artigo que compare o googletest com outros quadros ainda.

Um novo player é o Google Test (também conhecido como Google C ++ Testing Framework ), o que é bastante interessante.

#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
• Afirmações fatais e não fatais
• Mensagens informativas de afirmações fáceis :ASSERT_EQ(5, Foo(i)) << " where i = " << i;
• O Google Test detecta automaticamente seus testes e não exige que você os enumere para executá-los
• Facilite a extensão do seu vocabulário de asserção
• Testes de morte (consulte o guia avançado)
• SCOPED_TRACE para loops de rotina
• Você pode decidir quais testes executar
• Geração de relatório de teste XML
• Acessórios / Mock / Templates ...

Acabei de lançar minha própria estrutura, CATCH , por aí. Ainda está em desenvolvimento, mas acredito que já supera a maioria dos outros frameworks. Pessoas diferentes têm critérios diferentes, mas tentei cobrir a maior parte do terreno sem muitas trocas. Dê uma olhada na minha entrada de blog vinculada para uma degustação. Meus cinco principais recursos são:

• Apenas cabeçalho
• Registro automático de testes de função e método
• Decompõe expressões C ++ padrão em LHS e RHS (para que você não precise de uma família inteira de macros de afirmação).
• Suporte para seções aninhadas em um dispositivo baseado em função
• Testes de nome usando linguagem natural - nomes de função / método são gerados

Ele também possui ligações Objective-C. O projeto está hospedado no Github

A Biblioteca de Teste do Boost é uma escolha muito boa, especialmente se você já estiver usando o 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%
}

Suporta:

• Registro de testes automáticos ou manuais
• Muitas afirmações
• Comparação automática de coleções
• Vários formatos de saída (incluindo XML )
• Acessórios / Modelos ...

PS: Eu escrevi um artigo sobre isso que pode ajudá-lo a começar: Estrutura de teste de unidade C ++: um tutorial de teste de reforço

A Wikipedia possui uma lista abrangente de estruturas de teste de unidade , com tabelas que identificam os recursos suportados ou não.

Lançamos recentemente o xUnit ++ , especificamente como uma alternativa ao Google Test e à Boost Test Library (veja as comparações ). Se você conhece o xUnit.Net, está 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 são executados simultaneamente .
• Portátil
• Registro de teste automático
• Muitos tipos de asserção (o Boost não possui nada no xUnit ++)
• Compara coleções nativamente.
• As afirmações vêm em três níveis:
  • erros fatais
  • erros não fatais
  • avisos
• Registro de afirmação fácil :Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
• Registro de teste :Log.Debug << "Starting test"; Log.Warn << "Here's a warning";
• Luminárias
• Testes orientados a dados (teorias)
• Selecione em quais testes executar com base em:
  • Correspondência de atributos
  • Nome da substring correspondente
  • Suítes de teste

CppUTest - muito bom, estrutura leve com bibliotecas simuladas. Vale a pena dar uma olhada.

CPUnit ( http://cpunit.sourceforge.net ) é uma estrutura semelhante ao Google Test, mas que conta com menos macos (assertivas são funções) e onde as macros são prefixadas para evitar a armadilha comum de macro. Os testes são parecidos com:

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

}

Eles se registram automaticamente, então você não precisa mais do que isso. Depois é só compilar e executar. Acho que usar essa estrutura é muito parecido com o uso do JUnit, para aqueles que tiveram que gastar algum tempo programando Java. Muito agradável!

Existem alguns recursos relevantes de teste de unidade C ++ em http://www.progweap.com/resources.html

Verificador de integridade da API - estrutura de teste para bibliotecas C / C ++:

Um gerador automático de testes de unidade básicos para uma biblioteca C / C ++ compartilhada. É capaz de gerar dados de entrada razoáveis ​​(na maioria, mas infelizmente não todos) casos para parâmetros e compor casos de teste simples ("sanidade" ou "qualidade rasa") para todas as funções da API através da análise de declarações no cabeçalho arquivos.

A qualidade dos testes gerados permite verificar a ausência de erros críticos em casos de uso simples. A ferramenta é capaz de criar e executar testes gerados e detectar falhas (segfaults), interrupções, todos os tipos de sinais emitidos, código de retorno de programa diferente de zero e interrupção do programa.

Recursos exclusivos em comparação com CppUnit, Boost e Google Test:

• Geração automática de dados de teste e argumentos de entrada (mesmo para tipos de dados complexos)
• Tipos especializados modernos e altamente reutilizáveis, em vez de acessórios e modelos