Jak używać testu google do C++ do uruchamiania przez kombinacje danych

Question

Mam test jednostkowy, który muszę uruchomić dla 200 możliwych kombinacji danych. (W implementacji produkcyjnej są dane do przetestowania w plikach konfiguracyjnych, wiem, jak kpić z tych wartości). Wolę napisać osobny test testowy dla każdej kombinacji i użyć jakiegoś sposobu zapętlenia danych. Czy jest jakiś bezpośredni sposób korzystania z testu Google dla C++?

Dzięki Karthick

Answer 1

Możesz użyć do tego celu gtet's Value-parameterized tests.

Używanie tego w połączeniu z generatorem Combine(g1, g2, ..., gN) brzmi jak najlepiej.

Poniższy przykład wypełnia 2 vector s, jeden z int S, a drugi z string s, a następnie przy użyciu jednego urządzenia testowego tworzy testy dla każdej kombinacji dostępnych wartości w 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

Zastosowanie tablicę kodowanym (tzw powiedzmy Combination) do przechowywania danych testowych, a pętla choć każdego wpisu w jednym teście. Sprawdź każdą kombinację przy użyciu EXPECT_EQ zamiast ASSERT_EQ, aby test nie został przerwany i można kontynuować sprawdzanie innych kombinacji.

przeciążeniem operator<< dla Combination tak, że można wyprowadzać go do ostream:

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

przeciążeniem operator== dla Combination, dzięki czemu można łatwo porównać dwie kombinacje dla równości:

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

I test jednostki może wyglądać mniej więcej tak:

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"; 
}