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

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

Domanda

So che ci sono già alcune domande riguardo 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 già fatto un confronto?

È stato utile?

Soluzione

Visualizza questa domanda per qualche discussione.

Raccomandano gli articoli: Esplorazione della giungla del framework di test per unità C ++ , di Noel Llopis. E il più recente: Framework delle unità di test C ++

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

Altri suggerimenti

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:

  • Portable
  • Asserzioni fatali e non fatali
  • Asserzioni facili messaggi informativi : ASSERT_EQ(5, Foo(i)) << " where i = " << i;
  • Test di Google automaticamente rileva i test e non richiede di enumerarli per eseguirli
  • Rendi facile estendere il tuo vocabolario di asserzione
  • Test di morte (vedi guida avanzata)
  • SCOPED_TRACE per i cicli di subroutine
  • Puoi decidere quali test eseguire
  • XML generazione di rapporti di prova
  • Calendario / Manichino / 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 in 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:

  • Automatico o registrazione test manuale
  • Molte affermazioni
  • Confronto automatico di 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 test di unità , con tabelle che identificano le funzionalità supportate o meno .

Di recente ho pubblicato xUnit ++ , in particolare in alternativa a Google Test e alla libreria Boost Test (visualizza paragoni ). 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 eseguono contemporaneamente .
  • Portable
  • Automatico test di registrazione
  • Molti tipi di asserzioni (Boost non ha nulla su xUnit ++)
  • Confronta raccolte in modo nativo.
  • Le asserzioni sono disponibili in tre livelli:
    • errori fatali
    • errori non fatali
    • avvertenze
  • Registrazione facile : Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
  • Test registrazione: Log.Debug << "Starting test"; Log.Warn << "Here's a warning";
  • Calendario
  • Test basati sui dati (Teorie)
  • Seleziona i test da eseguire in base a:
    • Corrispondenza degli attributi
    • Corrispondenza sottostringa nome
    • Test Suites

CppUTest - quadro molto carino 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 (le asserzioni sono funzioni) e dove i macro hanno il prefisso per evitare la solita insidia 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 bello!

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

API Sanity Checker & # 8212; 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 sfortunatamente non tutti) per i parametri e comporre semplici (& Quot; sanità mentale & Quot; o & Quot; shallow & Quot; -quality ) testare casi per ogni funzione nell'API attraverso l'analisi delle dichiarazioni nei file di intestazione.

     

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)
  • Moderna e altamente riutilizzabile tipi specializzati anziché dispositivi e modelli
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top