Come utilizzare google test per C++ per eseguire combinazioni di dati

Question

Ho un test di unità che devo eseguire per 200 possibili combinazioni di dati. (L'implementazione di produzione ha i dati da testare nei file di configurazione. So come imitare questi valori). Preferisco la scrittura nit separata per ogni combinazione e per usare un modo per scorrere i dati. Esiste un modo così diretto di utilizzare Google test per C++?

Grazie, Karthick

Answer 1

Per questo è possibile utilizzare il numero Value-parameterized tests di gtest.

L'utilizzo di questo insieme al generatore Combine(g1, g2, ..., gN) suona come la soluzione migliore.

L'esempio seguente popola 2 vector s, una delle int s e l'altra di string s, quindi con un solo dispositivo di prova, crea prove per ogni combinazione di valori disponibili nelle 2 vector s:

#include <iostream> 
#include <string> 
#include <tuple> 
#include <vector> 
#include "gtest/gtest.h" 

std::vector<int> ints; 
std::vector<std::string> strings; 

class CombinationsTest : 
    public ::testing::TestWithParam<std::tuple<int, std::string>> {}; 

TEST_P(CombinationsTest, Basic) { 
    std::cout << "int: "  << std::get<0>(GetParam()) 
      << " string: \"" << std::get<1>(GetParam()) 
      << "\"\n"; 
} 

INSTANTIATE_TEST_CASE_P(AllCombinations, 
         CombinationsTest, 
         ::testing::Combine(::testing::ValuesIn(ints), 
              ::testing::ValuesIn(strings))); 

int main(int argc, char **argv) { 
    for (int i = 0; i < 10; ++i) { 
    ints.push_back(i * 100); 
    strings.push_back(std::string("String ") + static_cast<char>(i + 65)); 
    } 
    testing::InitGoogleTest(&argc, argv); 
    return RUN_ALL_TESTS(); 
} 

Answer 2

utilizzare un array di struct (chiamato, per esempio, Combination) per tenere i vostri dati di test e ciclo se ogni voce in un singolo test. Controlla ciascuna combinazione utilizzando EXPECT_EQ anziché ASSERT_EQ in modo che il test non venga interrotto e puoi continuare a controllare altre combinazioni.

sovraccarico operator<< per un Combination in modo che sia in grado di produrre a un ostream:

ostream& operator<<(ostream& os, const Combination& combo) 
{ 
    os << "(" << combo.field1 << ", " << combo.field2 << ")"; 
    return os; 
} 

sovraccarico operator== per un Combination in modo da poter facilmente confrontare due combinazioni per l'uguaglianza:

bool operator==(const Combination& c1, const Combination& c2) 
{ 
    return (c1.field1 == c2.field1) && (c1.field2 == c2.field2); 
} 

E il test unitario potrebbe assomigliare a questo:

TEST(myTestCase, myTestName) 
{ 
    int failureCount = 0; 
    for (each index i in expectedComboTable) 
    { 
     Combination expected = expectedComboTable[i]; 
     Combination actual = generateCombination(i); 
     EXPECT_EQ(expected, actual); 
     failureCount += (expected == actual) ? 0 : 1; 
    } 
    ASSERT_EQ(0, failureCount) << "some combinations failed"; 
}