C ++ Unit Testing Biblioteche [chiusa]

Question

ho incontrato CppUnit ma non sembrava super-facile da usare (forse non ho guardato difficile, forse perché C ++ non funziona come Java / C #). Sono ampiamente c'erano, alternative semplici?

In realtà, è CppUnit quadro unit testing standard per C ++?

Answer 1

Non c'è standard Unità libreria di test per C ++. Ci sono molte opzioni tra cui scegliere; CppUnit essere uno di loro.

Nella mia azienda usiamo Google prova insieme al suo partner Google Mock per unit testing e oggetto di scherno. Io li trovo entrambi abbinati più facile da usare e molto più potente di CppUnit.

Answer 2

Ho appena spinto il mio quadro, CATCH , là fuori. E 'ancora in fase di sviluppo, ma credo che supera già la maggior parte degli altri framework. Persone diverse hanno diversi criteri, ma ho cercato di coprire la maggior parte a terra senza troppi compromessi. Date un'occhiata al mio blog collegato per un assaggio. I miei primi cinque caratteristiche sono:

• solo Intestazione
• registrazione automatica di test basati metodi e funzioni
• Si decompone espressioni C ++ standard in LHS e RHS (quindi non hai bisogno di una intera famiglia di macro assert).
• Il supporto per le sezioni nidificate all'interno di un apparecchio basato funzione
• test nome utilizzando il linguaggio naturale - i nomi delle funzioni / metodi sono generati

Ha anche attacchi Objective-C.

A titolo di esempio, ecco come devi scrivere l'equivalente dell'esempio GTEST che @dmeister citati:

TEST_CASE( "Factorial/Handles zero input", "Tests factorial of 0.") 
{
  REQUIRE( Factorial(0) == 1 );
}

TEST_CASE( "Factorial/Handles positive input", "Tests factorial of positive numbers.") 
{
  REQUIRE( Factorial(1) == 1 );
  REQUIRE( Factorial(2) == 2 );
  REQUIRE( Factorial(3) == 6 );
  REQUIRE( Factorial(8) == 40320 );
}

Se un test fallito saresti ancora ottenere i valori LHS e RHS collegato independentaly.

Answer 3

Google prova Framework è un'alternativa.

Ecco un semplice esempio dal documentazione :

// Tests factorial of 0.
TEST(FactorialTest, HandlesZeroInput) {
  EXPECT_EQ(1, Factorial(0));
}

// Tests factorial of positive numbers.
TEST(FactorialTest, HandlesPositiveInput) {
  EXPECT_EQ(1, Factorial(1));
  EXPECT_EQ(2, Factorial(2));
  EXPECT_EQ(6, Factorial(3));
  EXPECT_EQ(40320, Factorial(8));
}

Si gioca anche bene con gmock , quadro finta di Google per C ++.

Answer 4

CppUnit probabilmente è il primo quadro di unit test per C ++. E 'una porta diretta di Junit, il famoso framework Java. Questo rende la transizione da Junit facile, ma al costo di un quadro alquanto pesante, che non approfittare di capacità C ++ come Raii. Questo è il motivo per cui sono state create le versioni leggeri come CppUnitLite, NanoCppUnit. CppUnit2 avrebbe dovuto migliorare questo, tra gli altri miglioramenti.

Tut usato per essere molto leggero, solo un colpo di testa, ma le ultime versioni ha introdotto una biblioteca.

Per quanto riguarda un quadro "standard" è interessato, non c'è nessuno, e C ++ 1X non definisce uno.

Answer 5

ho creato un test suite chiamata Saru ( http://github.com/mikeando/saru ) per il mio proprio codice dev. La sua una licenza BSD codice. Ho sviluppato come non mi piaceva molte delle caratteristiche di altre suite di test. La sua non è ampiamente utilizzato, ma l'ho usato su diversi progetti commerciali sparsi in due società.

1. non mi piace tutte le mie prove ottenendo compilati in un unico binario. Le ragioni per questo sono se la compilazione fallisce tutte le prove falliscono, se si prova non undefined comportamento l'output del programma è indefinito.
2. Voglio controllo su ciò che i test eseguiti. Voglio essere in grado di prove di gruppo e sottoinsiemi di esecuzione.
3. Voglio fallimento compilazione di un test per essere riportato come un fallimento del test, e non fermare tutti i miei test in esecuzione.
4. Voglio essere in grado di eseguire i test da più lingue diverse
5. Voglio un sistema abbastanza flessibile che posso eseguire test specifici nell'ambito valgrind (non ancora in Saru :()

Quindi Saru affronta la maggior parte di queste caratteristiche. Il suo obiettivo è quello di essere in grado di eseguire una serie di prove scritte in diverse lingue. Con dimensioni minime di prova. Ecco la più piccola (non) C ++ test

//SARU : dummy dummy
int main() { return (1==2)?0:1; }

Tutti Saru ha veramente a cuore è il valore di ritorno del binario che si compila. E 'quindi analizza l'output per determinare quali test falliti e così via. Ha intestazioni per fare lavorare con C ++ un po 'più bello rispetto alla banale esempio di cui sopra:

//SARU : dummy dummy
#include "MyStruct.h"
#include "saru_cxx.h"

class Fixture
{
  MyStruct s_;
  Fixture() : s_() {}
  void test_A_is_B()
  {
     SARU_ASSERT_EQUAL( s_.A(), s_.B() );
  }

  void test_C_is_7()
  {
     SARU_ASSERT_EQUAL( 7, s_.C() );
  }
};

int main()
{
   saru::TestLogger logger;
   SARU_TEST( Fixture:: test_A_is_B, logger );
   SARU_TEST( Fixture:: test_C_is_7, logger );
   logger.printSummary();
   return logger.allOK()?0:1;
}

Se non ti piace il modo in cui le sue intestazioni C ++ funzionano dovrebbe essere in grado di integrarsi con altre biblioteche unit testing con il minimo di difficoltà.

Ma sarà anche eseguire test che sono scritte in PHP e Python. Quindi è possibile impostare i test funzionali completi con Saru. In alternativa è possibile eseguire qualcosa di simile pelucchi sopra il vostro codice come parte della suite di test.

Answer 6

Ecco una libreria di test di unità minima C ++: https://github.com/vahidk/minimal-cpp-test

Ha sintassi molto simile a quella libreria di test Google, ma si tratta di un colpo di testa unica biblioteca e quindi più facile da porta tra le piattaforme.

Ecco una prova di unità minima:

#define DEFINE_TEST_MAIN    
#include "test.h"
TEST(GroupName, TestName) {
  EXPECT_EQ(1 + 2, 3);
}

E un appuntamento fisso minimo:

class ClassName : public cyrus:Test {
public:
  void Setup() override { 
    x = 5;
  }
  int x;
}

Test_F(ClassName, Test1) {
  EXPECT_EQ(x, 5);
}

Spero che questo aiuti.

Answer 7

Ecco un singolo file di intestazione includono unica soluzione per C ++ unit testing: https://gitlab.com/cppocl/unit_test_framework

Semplice esempio di utilizzo qui, ma ha anche infissi (setup e teardown), fallire prova su perdita di memoria, non riuscire prova sulle prestazioni (non ho visto questa funzione in qualsiasi altro luogo).

#include "test/Test.hpp"

TEST(MyTest)
{
    int a = 1;
    int b = 2;
    CHECK_EQUAL(a + b, 3);
}

Answer 8

Ecco un elenco di librerie di test di unità.

http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C .2B.2B

Tuttavia, per quanto ne so, CppUnit è il più popolare.