Confronto tra framework di test unitari C ++ [chiuso]

So che ci sono già alcune domande relative ai consigli per i framework di test unitari C ++, ma tutte le risposte non sono state utili in quanto raccomandano solo uno dei framework ma non forniscono alcuna informazione su un confronto (funzionalità).

Penso che i framework più interessanti siano CppUnit, Boost e il nuovo framework di test di Google. Qualcuno ha ancora fatto un confronto?

Vedi questa domanda per qualche discussione.

Raccomandano gli articoli: Exploring the C ++ Unit Testing Framework Jungle , di Noel Llopis. E il più recente: C ++ Test Unit Frameworks

Non ho ancora trovato un articolo che paragona il googletest agli altri framework.

Un nuovo giocatore è Google Test (noto anche come Google C ++ Testing Framework ) che è piuttosto carino.

#include <gtest/gtest.h>

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

Caratteristiche principali:

• Portatile
• Affermazioni fatali e non fatali
• Messaggi informativi di asserzioni facili :ASSERT_EQ(5, Foo(i)) << " where i = " << i;
• Google Test rileva automaticamente i tuoi test e non richiede di enumerarli per eseguirli
• Semplifica l' estensione del vocabolario delle asserzioni
• Test di morte (vedi guida avanzata)
• SCOPED_TRACE per i cicli di subroutine
• Puoi decidere quali test eseguire
• Generazione di report di test XML
• Calendario / Mock / Modelli ...

Ho appena spinto il mio framework, CATCH , là fuori. È ancora in fase di sviluppo, ma credo che superi già la maggior parte degli altri framework. Persone diverse hanno criteri diversi, ma ho cercato di coprire gran parte del terreno senza troppi compromessi. Dai un'occhiata al mio post sul blog collegato per un assaggio. Le mie cinque caratteristiche principali sono:

• Solo intestazione
• Registrazione automatica di test basati su funzioni e metodi
• Decompone le espressioni C ++ standard in LHS e RHS (quindi non è necessaria un'intera famiglia di assert macro).
• Supporto per sezioni nidificate all'interno di un dispositivo basato su funzioni
• Test dei nomi con linguaggio naturale: vengono generati nomi di funzioni / metodi

Ha anche attacchi Objective-C. Il progetto è ospitato su Github

Boost Test Library è un'ottima scelta soprattutto se stai già utilizzando 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%
}

Supporta:

• Registrazione di test automatici o manuali
• Molte affermazioni
• Confronto automatico delle collezioni
• Vari formati di output (incluso XML )
• Calendario / Modelli ...

PS: ho scritto un articolo a riguardo che potrebbe aiutarti a iniziare: C ++ Unit Testing Framework: A Boost Test Tutorial

Wikipedia ha un elenco completo di framework di unit test , con tabelle che identificano le funzionalità supportate o meno.

Di recente ho rilasciato xUnit ++ , in particolare come alternativa a Google Test e alla libreria Boost Test (vedi i confronti ). Se hai familiarità con xUnit.Net, sei pronto per 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));
}

Caratteristiche principali:

• Incredibilmente veloce: i test vengono eseguiti contemporaneamente .
• Portatile
• Registrazione test automatica
• Molti tipi di asserzioni (Boost non ha nulla su xUnit ++)
• Confronta le raccolte in modo nativo.
• Le asserzioni sono disponibili in tre livelli:
  • errori fatali
  • errori non fatali
  • avvertenze
• Registrazione facile di asserzione :Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
• Registrazione di prova :Log.Debug << "Starting test"; Log.Warn << "Here's a warning";
• infissi
• Test basati sui dati (Teorie)
• Seleziona i test da eseguire in base a:
  • Corrispondenza degli attributi
  • Nome matchin sottostringa
  • Test Suites

CppUTest - quadro molto bello e leggero con librerie finte . Vale la pena dare un'occhiata più da vicino.

CPUnit ( http://cpunit.sourceforge.net ) è un framework simile a Google Test, ma che si basa su meno macos (asserzioni sono funzioni) e in cui le macro sono precedute da prefissi per evitare le consuete insidie ​​delle macro. I test sembrano:

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

}

Si registrano automaticamente, quindi non è necessario altro. Quindi è solo compilare ed eseguire. Trovo che usare questo framework sia molto simile all'utilizzo di JUnit, per coloro che hanno dovuto trascorrere del tempo a programmare Java. Molto bella!

Ci sono alcune risorse rilevanti per i test delle unità C ++ su http://www.progweap.com/resources.html

API Sanity Checker - framework di test per librerie C / C ++:

Un generatore automatico di test unitari di base per una libreria C / C ++ condivisa. È in grado di generare dati di input ragionevoli (nella maggior parte, ma purtroppo non tutti,) per i parametri e comporre casi di test semplici ("sanità mentale" o "superficiale") per ogni funzione nell'API attraverso l'analisi delle dichiarazioni nell'intestazione File.

La qualità dei test generati consente di verificare l'assenza di errori critici in casi d'uso semplici. Lo strumento è in grado di costruire ed eseguire test generati e rilevare arresti anomali (segfault), interruzioni, tutti i tipi di segnali emessi, codice di ritorno del programma diverso da zero e blocco del programma.

Funzionalità uniche rispetto a CppUnit, Boost e Google Test:

• Generazione automatica di dati di test e argomenti di input (anche per tipi di dati complessi)
• Tipi specializzati moderni e altamente riutilizzabili invece di dispositivi e modelli