Comparação de frameworks de ensaio unit C++ [fechados]
Eu sei que já existem algumas perguntas sobre as recomendações para frameworks de teste de unidade C++, mas todas as respostas não ajudaram, uma vez que eles apenas recomendam um dos frameworks, mas não fornecem qualquer informação sobre uma comparação (característica).
Os quadros mais interessantes são o CppUnit, o Boost e o novo Google testing framework. Alguém já fez alguma comparação?10 answers
Veja esta questão para alguma discussão.
Eles recomendam os artigos.: Exploring the C++ Unit Testing Framework Jungle, By Noel Llopis. E o mais recente: Frameworks de Unidades de teste C++ Ainda não encontrei um artigo que Compare o googletest com os outros quadros.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 :
- 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 ...
ASSERT_EQ(5, Foo(i)) << " where i = " << i;
- 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.
}
}
Eles registram-se automaticamente, por isso não precisas de mais do que isto. Então é só compilar e correr. Acho que usar este framework é muito parecido com Usar o JUnit, para aqueles que tiveram que passar algum tempo programando Java. Muito bem!
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