Quale framework di test unitari per giochi basati su c ++? [chiuso]

Quale combinazione di strumenti di test ritieni migliore? Dato il framework / libreria di tua scelta potresti considerare:

• idoneità per TDD
• facilità d'uso / produttività
• trattare con oggetti finti
• installazione con integrazione continua
• segnalazione errori

Nota: mentre questa è potenzialmente una domanda generica come quella su SO , direi che lo sviluppo del gioco è generalmente legato a un flusso di lavoro specifico che influenza la scelta per il test. Per una prospettiva di livello superiore, vedi la domanda Test automatici dei giochi .

Ho trovato UnitTest ++ molto facile da lavorare. Mi hanno ancora provare Amop insieme con essa, che è stato detto di essere un buon compagno per unittest ++ per le funzionalità oggetto fittizio. Altrimenti Google Mock è una scelta popolare. Inoltre, potresti voler leggere su UnitTest ++ e Mock Objects .

UnitTest ++ può essere impostato con il tuo approccio di integrazione continua, ad es. Con Hudson

Potresti voler leggere questo post stimolante se non sei convinto che i test unitari e i giochi vadano bene insieme.

Un altro voto per UnitTest ++ . Molto facile da integrare, compilato per la nostra piattaforma integrata di destinazione in modo molto semplice, diretto e facile da usare. Lo abbiamo anche integrato con Hudson. Abbiamo esaminato GoogleTest ma lo abbiamo rifiutato (penso che avesse problemi di compilazione per la nostra piattaforma di destinazione) ma ha un set di funzioni simili e potrebbe essere adatto a te.

Inoltre, potresti voler esaminare una sorta di quadro di prova del fumo. Nella mia esperienza è difficile ottenere una copertura di prova sufficiente per un gioco con soli test unitari. Soprattutto se si sta introducendo test unitari in una base di codice esistente e persino per un team di grandi dimensioni. Il test del fumo testerebbe cose di alto livello come "assicurarsi che tutti i livelli vengano caricati". La mia teoria è che se avessi entrambi i tipi di test, ad un certo punto potrebbero incontrarsi nel mezzo e dare una discreta copertura. :)

Quando lavoravo in C ++ (dichiarazione di non responsabilità: era circa il 2005), utilizzavo una versione leggermente modificata di TUT (Template Unit Test Framework) . Mi è piaciuto perché era così leggero, il che ha reso facile la modifica, e significava che era richiesta pochissima "colla" durante la scrittura dei test.

Ecco una modifica molto semplice che ho fatto, che rende ancora più desideroso / pulito scrivere test:

static int BogusFunction() { return __COUNTER__; } // Increment the __COUNTER__ to the correct position for the begining of the tests
#define TEST template<> template<> void object::test<__COUNTER__>()
#define ENSURE(msg, cond) ensure(msg, cond, __FILE__, __LINE__)
#define ENSURE_EQUALS(msg, actual, expected) ensure_equals(msg, actual, expected, __FILE__, __LINE__)
#define ENSURE_DISTANCE(msg, actual, expected, distance) ensure_distance(msg, actual, expected, distance, __FILE__, __LINE__)
#define FAIL(msg) fail(msg, __FILE__, __LINE__)

L'altra modifica che ho apportato è stata il suo formato di output, in modo che gli errori di test apparissero correttamente nell'elenco degli errori di Visual Studios (quando eseguito come parte di una build), cliccabile per andare al file e alla riga del test fallito.

(La capacità di fare questo genere di mezzi cosa che si può essere fatto per adattarsi al vostro processo di TDD / CI, piuttosto che costringere a inserire nella sua.)

Ecco un esempio di test (dallo stack dei comandi dal mio editor):

TEST // Undoing a command
{
    cs.AddCommand(new TestCommand);
    cs.AddCommand(new TestCommand(od));

    ENSURE("Undo success", cs.Undo());
    ENSURE_EQUALS("Stack size", cs.size(), 2);
    ENSURE_EQUALS("Command's Undo() was called", od.undo, 1);
    ENSURE_EQUALS("Command's Redo() not called", od.redo, 0);

    ACommandStack::const_iterator it = cs.end();
    ENSURE("Command is redoable", cs.GetUndoPos() == --it);
}

(Nel codice sopra, cse odsono dispositivi per modulo, ed TestCommandè un oggetto finto.)

Quando si tratta di C ++, ho provato e utilizzato il framework più google, http://code.google.com/p/googletest/ . È semplice da configurare, facile da usare e funziona alla grande.

Non sono uno sviluppatore di giochi professionale, ma sono uno sviluppatore professionista incorporato. Forse non esattamente come i giochi, ma vicino. Nel mio posto di lavoro ne abbiamo usati alcuni.

Mi piace molto il test di Google . Ha tutte le migliori caratteristiche dei recenti framework di unit test, pur mantenendo tutto in un'interfaccia minimale e lineare.

Il prossimo sulla mia lista è Boost Test . L'API di Google Test è un po 'più moderna di Boost.Test, ma Boost Test ha fatto un lavoro straordinario aggiungendo nuove funzionalità e abbandonando il paradigma CppUnit.

Ho anche usato CxxTest . È abbastanza ben fatto ma puoi dire che non è moderno come Boost.Test o Google Test. In particolare, il suo supporto per le suite di test e gli apparecchi è un po 'imbarazzante.

Mi piace usare le funzionalità avanzate, ma se sei un minimalista non vedrai mai la differenza tra i tre. La maggior parte dei miei colleghi sarebbe contenta di un framework di unit test che supporta il test di registrazione automatica (in modo dichiarativo) e ha una sorta di macro CHECK_EQUALS (a, b).

La mia libreria di test preferita è QuickCheck http://it.wikipedia.org/wiki/QuickCheck . Esiste una versione sperimentale in C ++, ma sembra troppo pesante, ma anche senza una libreria dedicata i principi sono facili da usare.

Tutte le mie lezioni hanno un metodo genArbitrary che può generare un'istanza casuale. Lo uso per prove di fumo processi invertibili, come carico e scarico. Sono in grado di generare migliaia di scene casuali e verificare che siano presenti varie proprietà (come la scena che serializzo è la stessa della scena che deserializzo).

Non sostituisce i test unitari tradizionali (riduce la necessità di molti potenziali test unitari), ma è un ottimo modo per scoprire i bug e aiuta a stressare la mia strategia di allocazione della memoria (insieme a Valgrind). È bello vedere oltre un milione di allocazioni uscire Valgrind pure :).

Usavo CxxTest come imbrago di prova, che mi piaceva. Ora tutti i miei test sono ex separati. Ho solo una cartella chiamata Test e ogni file che inizia con Test_ diventa un test. Finora è molto leggero per fare test.

Con Java, ci sono così tante buone librerie ... Non nel caso del C ++.

Per gli utenti C ++, esiste uno strumento a catena di Kitware che è molto interessante:

• CMake: crea strumento
• CDash: strumento di integrazione continua

Kitware scrive codici C ++ per Informatica.

Per i progetti personali, utilizzo la libreria di test delle unità Boost (sulla piattaforma desktop). Per l'integrazione continua, utilizzo Hudson:

• facile installazione su Tomcat
• script

Sarò secondo il framework TUT (Template Unit Test) ; è super leggero ed estremamente flessibile, per non parlare del fatto che è facile da configurare e utilizzare immediatamente (una singola intestazione include, un po 'di codice principale / di configurazione e 24 righe di codice di test in seguito hai un test unitario). L'ho combinato con binfmtc (esegui programmi C ++ come script) per prototipi rapidi / TDD / modelli di apprendimento con grande successo, incluso lo sviluppo di software incorporato. Grazie alla sua capacità di produrre in XML, si è anche adattato perfettamente a Jenkins (CI) e Sonar su miei progetti successivi.