Passing a typename and string to parameterized tes

Question

Is there a way of passing both a type and a string to a parametrized test using google's test.

I would like to do:

template <typename T>
class RawTypesTest : public ::testing::TestWithParam<const char * type> {
protected:
  virtual void SetUp() {
       message = type;
  }
}; 

TEST_P(RawTypesTest, Foo) {
  ASSERT_STREQ(message, type);
  ParamType * data = ..;
  ...
}

Thanks in advance

Answer 1

I did not research what TYPED_TEST_P family of macros does internally, but I find using them extra complicated for the goal. You could achieve the same simply encoding the parameter as part of the type.

#define TSLP(name, value) \
struct Tslp##name \
{ \
   std::string operator()() \
   { \
      return value; \
   } \
}

TSLP(Empty, "");
TSLP(Foo, "foo");
template<class Type, class Param>
class ParamTextFixture : public Type {
    static std::string message() {
        return Param()();
    }
}

then all you need to do is in the types to replace your class with the ParamTextFixture

typedef ::testing::Types<
    ParamTextFixture<MyClass, TslpEmpty>
    , ParamTextFixture<MyClass, TslpFoo> >
...

Answer 2

Value parameterized tests won't work for passing type information; you can only do that with typed or type parameterized tests. In both cases you'll have to package your type and string information into special structures. Here is how to do it with type-parameterized tests:

template <typename T> class RawTypesTest : public testing::Test {
 public:
  virtual void SetUp() {
    this->message_ = TypeParam::kStringValue;
  }

 protected:
  const char* const message_;
}

TYPED_TEST_CASE_P(RawTypesTest);

TYPED_TEST_P(RawTypesTest, DoesFoo) {
  ASSERT_STREQ(message, TypeParam::kStringValue);
  TypeParam::Type* data = ...;
}

TYPED_TEST_P(RawTypesTest, DoesBar) { ... }

REGISTER_TYPED_TEST_CASE_P(FooTest, DoesFoo, DoesBar);

And now you have to define the parameter structures and instantiate the tests for them:

struct TypeAndString1 {
  typedef Type1 Type;
  static const char* kStringValue = "my string 1";
};
const char* TypeAndString1::kStringValue;

struct TypeAndString2 {
  typedef Type1 Type;
  static const char* kStringValue = "my string 2";
};
const char* TypeAndString2::kStringValue;

typedef testing::Types<TypeAndString1, TypeAndString2> MyTypes;
INSTANTIATE_TYPED_TEST_CASE_P(OneAndTwo, RawTypeTest, MyTypes);

You can use a macro to simplify definition of your parameter types:

#define MY_PARAM_TYPE(name, type, string) \
  struct name { \
    typedef type Type; \
    static const char kStringValue = string; \
  }; \
  const char* name::kStringValue

Then definitions of parameter structs become much shorter:

MY_PARAM_TYPE(TypeAndString1, Type1, "my string 1");
MY_PARAM_TYPE(TypeAndString2, Type2, "my string 2");

This is quite complicated but there is no easy way to do this. My best advice is to try re-factor your tests to avoid requiring both type and value information. But if you must, here is the way.