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

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

Pergunta

Eu sei que existem já algumas perguntas sobre recomendações para estruturas de teste de unidade C ++, mas todas as respostas não ajudou, pois apenas recomendar um dos quadros, mas não fornecem qualquer informação sobre um (recurso) comparação.

Eu acho que a maioria dos enquadramentos interessantes são CppUnit, Boost e o novo framework de testes do Google. Alguém feito qualquer comparação ainda?

Foi útil?

Solução

Veja esta questão para alguma discussão.

Eles recomendam os artigos: Explorando o C ++ Unit Testing Framework selva, por Noel Llopis. E o mais recente: C ++ unidade de teste Frameworks

Eu não encontrei um artigo que compara googletest aos outros quadros ainda.

Outras dicas

Um novo jogador é Google Teste (também conhecido como Google C ++ Testing Framework ), 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";
}

características principais:

  • portátil
  • Fatal e afirmações não fatais
  • afirmações fáceis informativo mensagens : ASSERT_EQ(5, Foo(i)) << " where i = " << i;
  • Google Teste automaticamente detecta seus testes e não requer que você enumerá-los, a fim de executá-los
  • Faça fácil estender a sua afirmação de vocabulário
  • testes Morte (veja o guia avançado)
  • SCOPED_TRACE para sub-rotina laços
  • Você pode decidir que os testes para executar
  • XML geração de relatório de ensaio
  • Luminárias / Mock / Modelos ...

Eu só empurrou meu próprio quadro, CATCH , lá fora. É ainda em desenvolvimento, mas acredito que já supera a maioria dos outros frameworks. Diferentes pessoas têm critérios diferentes, mas eu tentei cobrir mais terreno sem muitos trade-offs. Dê uma olhada no meu blog ligado para um provador. Meus top cinco características são:

  • Apenas cabeçalho
  • Registro Auto da função e testes baseados método
  • Decompõe expressões C ++ padrão em LHS e RHS (assim você não precisa de uma família inteira de macros do assert).
  • Suporte para seções aninhados dentro de um dispositivo elétrico baseado em função
  • testa Nome usando linguagem natural - nomes função / método são gerados

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

impulsionar Biblioteca Teste é uma escolha muito boa, especialmente se você já 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%
}

Ele suporta:

  • automático ou manual de testes de registro
  • Muitos afirmações
  • Comparação automática da coleções
  • Vários formatos de saída (incluindo XML )
  • Luminárias / Modelos ...

PS: Eu escrevi um artigo sobre ele que pode ajudá-lo a começar: C ++ Unit Testing Framework : um impulso Teste Tutorial

Wikipedia tem um href="http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks" abrangente da unidade de estruturas de teste , com mesas que identificam características suportadas ou não .

Eu lançou recentemente xUnit ++ , especificamente como uma alternativa ao Google Test and Boost Biblioteca Test (ver o comparações ). Se você estiver familiarizado com xUnit.Net, você está pronto 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 principais:

  • incrivelmente rápido:. Testes executados simultaneamente
  • portátil
  • automático Registro de teste
  • Muitos tipos de declaração (boost não tem nada sobre xUnit ++)
  • Compara coleções nativamente.
  • As afirmações vêm em três níveis:
    • erros fatais
    • erros não fatais
    • avisos
  • Fácil assert login: Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
  • Test logging: Log.Debug << "Starting test"; Log.Warn << "Here's a warning";
  • Luminárias
  • <> fortes Data-driven fortes provas (Teorias)
  • Selecionar que testa para executar com base em:
    • correspondência Atributo
    • Nome substring matchin
    • Test Suites

CppUTest - quadro peso muito agradável, leve, com bibliotecas simulados. Vale a pena tomar um olhar mais atento.

CPUnit ( http://cpunit.sourceforge.net ) é uma estrutura que é semelhante ao Google Teste, mas que se baseia em menos MacOS (afirma são funções), e onde as macros são prefixados para evitar o habitual armadilha macro. Testes parecido: 

#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 auto-registo, para que não mais do que isso precisa. Em seguida, ele é apenas compilar e executar. Acho usando este quadro muito parecido com JUnit, para aqueles que tiveram que passar algum tempo de programação Java. Very nice!

Há alguns C ++ recursos de teste de unidade relevantes a http://www.progweap.com/resources.html

API Sanity Checker - estrutura de teste para bibliotecas C / C ++:

Um gerador automático de testes unitários básicos para uma biblioteca de C / C ++ compartilhada. Ele é capaz de gerar razoável (na maior parte, mas infelizmente não todos, os casos) dados de entrada para os parâmetros e simples de composição ( "sanidade" ou -qualidade "superficial") casos de teste para cada função na API através da análise das 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 construir e executar testes gerados e detectar colisões (segfaults), aborts, todos os tipos de sinais emitidos, diferente de zero programa de código de retorno e de suspensão do programa.

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

  • A geração automática de dados de teste e argumentos de entrada (mesmo para tipos de dados complexos)
  • Modern e altamente reutilizável tipos especializados em vez de utensílios e templates
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top