GTest - параметризованные тесты для разных типов - PullRequest
Новая
       7

GTest - параметризованные тесты для разных типов

2 голосов
/ 13 мая 2019

Я бы хотел смешать параметризованный тест с типизированным тестом. Вот моя попытка: 

struct X {};

struct Y {};

template <typename T>
struct MyTestFixture: public ::testing::Test
{
    T t;
};

template <typename T, typename Param>
struct MyTestFixtureWithParam : public MyTestFixture<T>, 
                                public ::testing::WithParamInterface<Param>
{
};

using MyTestFixtureWithXandString = MyTestFixtureWithParam<X, std::string>;

TEST_P(MyTestFixtureWithXandString, Test1)
{
}

INSTANTIATE_TEST_CASE_P(Name, MyTestFixtureWithXandString, 
                        ::testing::Values("a", "b"));

using MyTestFixtureWithYandString = MyTestFixtureWithParam<Y, std::string>;

TEST_P(MyTestFixtureWithYandString, Test1)
{

}

INSTANTIATE_TEST_CASE_P(Name, MyTestFixtureWithYandString, 
                        ::testing::Values("a", "b"));

Содержит ли Gtest какой-либо макрос, который смешивает TYPED_TEST и TEST_P, или приведенный выше код - единственный способ достичь моей цели?

1 Ответ

1 голос
/ 17 мая 2019

Насколько я знаю, такого макроса может и не быть, но есть один из возможных способов сделать это следующим образом.

Основная идея

Давайте определим следующие структуры a, b и Case. Здесь a::str и b::str - это параметры, которые мы хотим проверить: 

// types
struct X {};
struct Y {};

// "parameters"
struct a { static constexpr char str[] = "a"; };
struct b { static constexpr char str[] = "b"; };

template<class T, class P>
struct Case
{
    using type = T;

    static std::string GetParam()
    {
        return P::str;
    }
};

Основная идея тестирования всех комбинаций ваших типов X и Y и строковых параметров в одной логике тестирования заключается в использовании этой структуры Case для указания типа и параметра теста следующим образом: 

using TestTypes = ::testing::Types<Case<X, a>, Case<X, b>, Case<Y, a>, Case<Y, b>>;

template <class T>
class MyTestFixture: public ::testing::Test {};

TYPED_TEST_CASE(MyTestFixture, TestTypes);

TYPED_TEST(MyTestFixture, Test12) 
{
    // X or Y
    TypeParam::type t;

    // "a" or "b"
    const std::string str = TypeParam::GetParam();
}

Улучшение

Теперь наша проблема в том, как мы можем улучшить построение всех комбинаций типов и строковых параметров. Я ответил на почти такую ​​же проблему . В текущем случае все возможные пары {X, Y} и {a, b} помечены одномерными целыми числами 0,1,2,3 следующим образом: 

0 -> (0/2, 0%2) = (0,0) -> Case<X, a>
1 -> (1/2, 1%2) = (0,1) -> Case<X, b>
2 -> (2/2, 2%2) = (1,0) -> Case<Y, a>
3 -> (3/2, 3%2) = (1,1) -> Case<Y, b>

, где 2 - размер {a, b}. Это просто написать функцию, которая делает все возможные комбинации с этим алгоритмом следующим образом. Например, Combinations_t<std::tuple<X, Y>, a, b> соответствует типу std::tuple<Case<X,a>, Case<X,b>, Case<Y,a>, Case<Y,b>>:

Live DEMO 

template<class TupleType, class TupleParam, std::size_t I>
struct make_case
{
    static constexpr std::size_t N = std::tuple_size<TupleParam>::value;

    using type = Case<typename std::tuple_element<I / N, TupleType >::type,
                      typename std::tuple_element<I % N, TupleParam>::type>;
};

template <class T1, class T2, class Is>
struct make_combinations;

template <class TupleType, class TupleParam, std::size_t... Is>
struct make_combinations<TupleType, TupleParam, std::index_sequence<Is...>>
{
    using tuples = std::tuple<typename make_case<TupleType, TupleParam, Is>::type...>;
};

template<class TupleTypes, class... Params>
using Combinations_t = typename make_combinations
                       <TupleTypes,
                        std::tuple<Params...>,
                        std::make_index_sequence<(std::tuple_size<TupleTypes>::value)*(sizeof...(Params))>>
                     ::tuples;

Применяя ответы к этому сообщению , мы можем разбить этот кортеж Combinations_t<...> на список типов, и здесь я применяю простой способ Наваза. Затем, наконец, все тесты можно выполнить следующим образом: 

template <class T>
class MyTestFixture : public ::testing::Test {};

template<class T>
struct Test;

template<class ...T>
struct Test<std::tuple<T...>>
{
    using Types = ::testing::Types<T...>;
};

using TestTypes = Test<Combinations_t<std::tuple<X, Y>, a, b>>::Types;

TYPED_TEST_CASE(MyTestFixture, TestTypes);

TYPED_TEST(MyTestFixture, Test12)
{
    // X or Y
    TypeParam::type t;

    // "a" or "b"
    const std::string str = TypeParam::GetParam();
}
...