2011-08-26 21 views
71

utilizzando Google Test 1.6 (Windows 7, Visual Studio C++). Come posso disattivare un determinato test? (aka come posso impedire l'esecuzione di un test). C'è qualcosa che posso fare oltre a commentare l'intero test?GoogleTest: come saltare un test?

risposta

98

Il docs per Google prova 1.7 suggest: ". Se si dispone di un test di rotta che non si può risolvere subito, è possibile aggiungere il prefisso DISABLED_ al suo nome Questo si può escluderlo dalla esecuzione"

Esempi:

// Tests that Foo does Abc. 
TEST(FooTest, DISABLED_DoesAbc) { ... } 

class DISABLED_BarTest : public ::testing::Test { ... }; 

// Tests that Bar does Xyz. 
TEST_F(DISABLED_BarTest, DoesXyz) { ... } 
+0

appena trovato troppo e filtri – User

+0

esso @ Bill, l'ho trovato poco prima che tu scrivessi il tuo commento ... (e l'ho messo anche come risposta). Ho quindi rimosso il mio commento, immaginando che sia obsoleto ... ma sono alcune ottime informazioni! +1 – Kiril

46

È possibile anche run a subset of tests, secondo la documentazione:

Esecuzione di un sottoinsieme dei test

Per impostazione predefinita, il programma Google prova corre tutto test che l'utente ha definito. A volte, si desidera eseguire solo un sottoinsieme dei test (ad esempio per il debug o per verificare rapidamente una modifica). Se imposti la variabile di ambiente GTEST_FILTER o il flag --gtest_filter su una stringa di filtro, il test esegue solo i test i cui nomi completi (nel formato TestCaseName.TestName) corrispondono al filtro.

Il formato di un filtro è un ':' - elenco separato dei modelli jolly (chiamati modelli positivi) eventualmente seguito da un '-' e un'altra ':' - lista modello separato (chiamato schemi negativi) . Un test corrisponde al filtro se e solo se corrisponde a uno degli schemi positivi ma non corrisponde a nessuno dei pattern negativi.

Un motivo può contenere "*" (corrisponde a qualsiasi stringa) o "?" (corrisponde a qualsiasi carattere singolo ). Per comodità, il filtro '* -NegativePatterns' può anche essere scritto come '-NegativePatterns'.

Ad esempio:

./foo_test Has no flag, and thus runs all its tests. 
./foo_test --gtest_filter=* Also runs everything, due to the single match-everything * value. 
./foo_test --gtest_filter=FooTest.* Runs everything in test case FooTest. 
./foo_test --gtest_filter=*Null*:*Constructor* Runs any test whose full name contains either "Null" or "Constructor". 
./foo_test --gtest_filter=-*DeathTest.* Runs all non-death tests. 
./foo_test --gtest_filter=FooTest.*-FooTest.Bar Runs everything in test case FooTest except FooTest.Bar. 

non è la soluzione più bella, ma funziona.

5

Se sono necessari più di un test essere saltati

--gtest_filter=-TestName.*:TestName.*TestCase 
4

Per un altro approccio, si può avvolgere i test in una funzione e usare i normali controlli condizionali a runtime per eseguire solo se vuoi.

#include <gtest/gtest.h> 

const bool skip_some_test = true; 

bool some_test_was_run = false; 

void someTest() { 
    EXPECT_TRUE(!skip_some_test); 
    some_test_was_run = true; 
} 

TEST(BasicTest, Sanity) { 
    EXPECT_EQ(1, 1); 
    if(!skip_some_test) { 
     someTest(); 
     EXPECT_TRUE(some_test_was_run); 
    } 
} 

Questo è utile per me come io sto cercando di eseguire alcuni test solo quando un sistema supporta dual stack IPv6.

Tecnicamente, il materiale dualstack non dovrebbe essere un test unitario in quanto dipende dal sistema. Ma non posso davvero fare alcun test di integrazione fino a quando non ho testato che funzionano comunque e questo assicura che non segnalerà guasti quando non è colpa dei codici.

Per quanto riguarda il test, ho degli oggetti stub che simulano il supporto di un sistema per il dualstack (o la mancanza di) mediante la costruzione di prese false.

L'unico svantaggio è che l'output di test e il numero di test cambieranno, il che potrebbe causare problemi con qualcosa che monitora il numero di test riusciti.

È inoltre possibile utilizzare ASSERT_ * anziché EQUAL_ *. Assert sarà circa il resto del test se fallisce. Impedisce che molta roba ridondante venga scaricata nella console.

12

Ecco l'espressione per includere i test i cui nomi hanno le stringhe foo1 o foo2 in loro ed escludono i test i cui nomi hanno il bar1 stringhe o bar2 in loro:

--gtest_filter=*foo1*:*foo2*-*bar1*:*bar2* 
4

preferisco farlo in codice:

// Run a specific test only 
//testing::GTEST_FLAG(filter) = "MyLibrary.TestReading"; // I'm testing a new feature, run something quickly 

// Exclude a specific test 
testing::GTEST_FLAG(filter) = "-MyLibrary.TestWriting"; // The writing test is broken, so skip it 

posso neanche commentare entrambe le linee per eseguire tutti i test, rimuovere il commento fuori la prima linea per testare una sola caratteristica che sto indagando/lavorando, o rimuovere il commento dalla seconda linea se un test è rotto, ma io voglio per testare tutto il resto.
È inoltre possibile testare/escludere una serie di funzionalità utilizzando i caratteri jolly e scrivendo un elenco, "MyLibrary.TestNetwork *" o "-MyLibrary.TestFileSystem *".

+0

Questa è un'ottima soluzione. Lo uso per escludere alcuni test di default se il filtro è vuoto. Possono essere abilitati con 'export GTEST_FILTER = '*''. – Timmmm

+0

In realtà non funziona perché l'impostazione predefinita è "' * "" non "". Invece userò solo un'altra variabile d'ambiente che sovrascrive il filtro. – Timmmm

0

Avevo lo stesso bisogno di test condizionali e ho trovato una buona soluzione. Ho definito una macro TEST_C che funziona come una macro TEST_F, ma ha un terzo parametro, che è un'espressione booleana, ha valutato il runtime in main.cpp PRIMA che i test siano avviati. I test che valutano false non vengono eseguiti. La macro è brutto, ma apparire come:

#pragma once 
extern std::map<std::string, std::function<bool()> >* m_conditionalTests; 
#define TEST_C(test_fixture, test_name, test_condition)\ 
class test_fixture##_##test_name##_ConditionClass\ 
{\ 
    public:\ 
    test_fixture##_##test_name##_ConditionClass()\ 
    {\ 
     std::string name = std::string(#test_fixture) + "." + std::string(#test_name);\ 
     if (m_conditionalTests==NULL) {\ 
      m_conditionalTests = new std::map<std::string, std::function<bool()> >();\ 
     }\ 
     m_conditionalTests->insert(std::make_pair(name, []()\ 
     {\ 
      DeviceInfo device = Connection::Instance()->GetDeviceInfo();\ 
      return test_condition;\ 
     }));\ 
    }\ 
} test_fixture##_##test_name##_ConditionInstance;\ 
TEST_F(test_fixture, test_name) 

Inoltre, nel vostro main.cpp, avete bisogno di questo ciclo di escludere le prove che valutano falso:

// identify tests that cannot run on this device 
std::string excludeTests; 
for (const auto& exclusion : *m_conditionalTests) 
{ 
    bool run = exclusion.second(); 
    if (!run) 
    { 
     excludeTests += ":" + exclusion.first; 
    } 
} 

// add the exclusion list to gtest 
std::string str = ::testing::GTEST_FLAG(filter); 
::testing::GTEST_FLAG(filter) = str + ":-" + excludeTests; 

// run all tests 
int result = RUN_ALL_TESTS(); 
Problemi correlati