Teste de unidade para código C ++ - Ferramentas e metodologia [fechado]

Estou trabalhando em um grande sistema c ++ que está em desenvolvimento há alguns anos. Como parte de um esforço para melhorar a qualidade do código existente, nos envolvemos em um grande projeto de refatoração de longo prazo.

Você conhece uma boa ferramenta que pode me ajudar a escrever testes de unidade em C ++? Talvez algo parecido com Junit ou Nunit?

Alguém pode dar bons conselhos sobre a metodologia de escrever testes de unidade para módulos que foram escritos sem o teste de unidade em mente?

A aplicação de testes de unidade ao código legado foi o motivo pelo qual o Working Effectively with Legacy Code foi escrito. Michael Feathers é o autor - como mencionado em outras respostas, ele esteve envolvido na criação do CppUnit e do CppUnitLite .

O Google lançou recentemente sua própria biblioteca para aplicativos C ++ de teste de unidade, chamada Google Test.

Projeto no Google Code

Confira uma excelente comparação entre várias suítes disponíveis. O autor desse artigo posteriormente desenvolveu o UnitTest ++ .

O que eu particularmente gosto nele (além do fato de que ele lida com exceções etc.) é que existe uma quantidade muito limitada de 'administração' em torno dos casos de teste e da definição dos equipamentos de teste.

O Boost possui uma biblioteca de testes que contém suporte para testes de unidade. Pode valer a pena conferir.

Noel Llopis, da Games From Within, é o autor de Explorando a Selva da Estrutura de Teste de Unidade C ++ , uma avaliação abrangente (mas agora datada) das várias estruturas de Teste de Unidade C ++, além de um livro sobre programação de jogos.

Ele usou o CppUnitLite por um bom tempo, consertando várias coisas, mas acabou unindo forças com outro autor da biblioteca de teste de unidade e produziu o UnitTest ++ . Usamos o UnitTest ++ aqui, e eu gosto muito até agora. Ele tem (para mim) o equilíbrio exato exato de poder com uma pequena pegada.

Eu usei soluções caseiras, CxxTest (que requer Perl) e boost :: test. Quando implementei o teste de unidade aqui no meu trabalho atual, ele se resumiu a UnitTest ++ vs boost :: test.

Eu realmente gosto da maioria das bibliotecas de impulso que já usei, mas IMHO, boost :: test é um pouco pesado demais. Eu particularmente não gostei do fato de exigir que você (AFAIK) implemente o programa principal do equipamento de teste usando uma macro boost :: test. Sei que não é TDD "puro", mas às vezes precisamos de uma maneira de executar testes usando um aplicativo GUI, por exemplo, quando um sinalizador de teste especial é passado na linha de comando e o boost :: test não pode suportar esse tipo do cenário.

O UnitTest ++ foi a estrutura de teste mais simples de configurar e usar que encontrei na minha experiência (limitada).

Estou usando a excelente biblioteca Boost.Test em conjunto com uma biblioteca Turtle muito menos conhecida, mas tão incrível : uma biblioteca de objetos falsos baseada em boost.

Como um exemplo de código fala melhor que palavras, imagine que você gostaria de testar um calculatorobjeto que funcione em uma viewinterface (que é o exemplo introdutório de Turtle):

// declares a 'mock_view' class implementing 'view'
MOCK_BASE_CLASS( mock_view, view )
{
    // implements the 'display' method from 'view' (taking 1 argument)
    MOCK_METHOD( display, 1 )                   
};

BOOST_AUTO_TEST_CASE( zero_plus_zero_is_zero )
{
    mock_view v;
    calculator c( v );

    // expects the 'display' method to be called once with a parameter value equal to 0
    MOCK_EXPECT( v, display ).once().with( 0 ); 

    c.add( 0, 0 );
}

Veja como é fácil e detalhado declarar expectativa no objeto simulado? Obviamente, o teste falhará se as expectativas não forem atendidas.

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 prova. 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 CxxTest é um framework JUnit / CppUnit / xUnit, leve, fácil de usar e multiplataforma para C ++.

CppUnit é o caminho. Veja o link abaixo:

http://cppunit.sourceforge.net/cppunit-wiki

http://en.wikipedia.org/wiki/CppUnit

UnitTest ++ , pequeno e simples.

Atualmente, estou procurando um teste de unidade e uma estrutura simulada que possa ser usada em nossa empresa por uma longa base de código. Como você sabe que a lista de estruturas de teste de unidade para c ++ é longa, apliquei alguns filtros para reduzi-lo a um total que pode ser visto mais de perto. O primeiro critério de filtro foi que ele deve ser gratuito. O segundo critério foi a atividade do projeto. Também procurei estruturas de simulação porque você precisa de uma para escrever testes de unidade.

Eu vim com a seguinte lista (aproximadamente) classificada por atividade, a atividade mais alta no topo:

• GoogleTest / GoogleMock: muitos colaboradores e usados ​​pelo próprio Google. Provavelmente, estará aqui por algum tempo e receberá atualizações. Para minha base de código privada, mudarei para essa combinação na esperança de pular no trem mais rápido.

• BoostTest + Turtle: não é atualizado com frequência, mas a estrutura de teste faz parte do impulso, portanto deve ser mantida. A tartaruga, por outro lado, é mantida principalmente por um indivíduo, mas apresenta atividade ressentida, portanto não está morta. Fiz quase toda a minha experiência de teste com essa combinação, porque já usamos a biblioteca de impulso no meu trabalho anterior e atualmente a uso para meu código privado.

• CppUTest: fornece testes e zombarias. Este projeto está ativo de 2008 a 2015 e possui uma atividade bastante recente. Essa descoberta foi uma surpresa, porque muitos projetos com significativamente menos atividade surgem com mais frequência ao pesquisar na Web (como o CppUnit, que teve sua última atualização em 2013). Eu não olhei mais fundo nisso, então não posso dizer nada sobre os detalhes. Edit (16.12.2015): Eu tentei recentemente isso e achei esse quadro um pouco desajeitado e "estiloso", especialmente ao usar as classes simuladas. Também parecia ter uma variedade menor de afirmações do que outras estruturas. Eu acho que sua principal força é que ele pode ser usado com projetos de C puros.

• QTest: a biblioteca de teste que acompanha a estrutura Qt. A manutenção deve ser garantida por algum tempo, mas eu a uso como uma biblioteca de suporte, porque o registro de teste é IMO mais desajeitado do que em outras estruturas. Tanto quanto eu entendo, isso obriga a ter um exe de teste por dispositivo de teste. Porém, as funções auxiliares de teste podem ser úteis ao testar o código Qt-Gui. Não tem zombaria.

• Captura: possui atividade recente, mas é desenvolvida principalmente por um indivíduo. O bom dessa estrutura é a abordagem alternativa de fixação, que permite escrever código de fixação reutilizável no próprio teste. Ele também permite que você defina os nomes dos testes como strings, o que é bom quando você costuma escrever frases inteiras como nomes de teste. Eu gostaria que esse estilo fosse rasgado e colocado no googleTest ;-)

Mock Frameworks

O número de estruturas simuladas é muito menor que o número de estruturas de teste, mas aqui estão as que eu descobri que possuem atividades recentes.

• Hippomock : ativo a partir de 2008 unitl agora, mas apenas com baixa intensidade.

• FakeIt : ativo a partir de 2013 unitl agora, mas mais ou menos desenvolvido por um cara.

Conclusão

Se a sua base de código estiver em longo prazo, escolha entre o BoostTest + Turtle e o GoogleTest + GoogleMock . Eu acho que esses dois terão manutenção a longo prazo. Se você tiver apenas uma base de código de curta duração, poderá experimentar o Catch, que possui uma boa sintaxe. Então você precisaria escolher adicionalmente uma estrutura de simulação. Se você trabalha com o Visual Studio, pode fazer o download dos adaptadores test-runner para BoostTest e GoogleTest, que permitirão executar os testes com a GUI do test runner integrada ao VS.

Consulte também as respostas para a pergunta intimamente relacionada "escolhendo uma ferramenta / estrutura de teste de unidade c ++", aqui

Também há TUT , Template-Unit-Test, uma estrutura baseada em modelo. Sua sintaxe é estranha (alguns chamam de abuso de modelo), mas sua principal vantagem é que tudo está contido em um único arquivo de cabeçalho .

Você encontrará um exemplo de teste de unidade escrito com o TUT aqui.

Eu tentei o CPPunit e não é muito fácil de usar.

A única alternativa que eu sei é usar C ++. NET para agrupar suas classes C ++ e escrever testes de unidade com uma das estruturas de teste de unidade .NET (NUnit, MBUnit etc.)

O CppUTest é uma excelente estrutura leve para testes de unidade C e C ++.

Michael Feathers do ObjectMentor foi fundamental no desenvolvimento do CppUnit e do CppUnitLite.

Ele agora recomenda o CppUnitLite

Dê uma olhada no CUnitWin32 . Foi escrito para o MS Visual C. Inclui um exemplo.

Dê uma olhada no cfix ( http://www.cfix-testing.org ), que é especializado no desenvolvimento do Windows C / C ++ e suporta testes de unidade no modo usuário e no modo kernel.

Se você estiver no Visual Studio 2008 SP1, recomendo usar o MSTest para escrever os testes de unidade. Eu uso o Google mock para escrever as zombarias. A integração com o IDE é ideal e permite e não carrega a sobrecarga do CPPunit em termos de edição de três locais para a adição de um teste.

Eu acho que o VisualAssert está fazendo um ótimo trabalho na integração do VS. Ele permite executar e depurar os testes do VS e você não precisa criar um executável para executar os testes.

Confira a frutose: http://sourceforge.net/projects/fructose/

É uma estrutura muito simples, contendo apenas arquivos de cabeçalho e, portanto, fácil de transportar.

Estou usando o MS Test com o Typemock Isolator ++ . De uma chance!