在 TYPED_TEST 中获取 TypeParam()

Question

我有一个模板类，它将data type T 和size_t size 作为模板化参数，并为客户端类编写了一些单元测试。我在两个不同的地方重复相同类型的代码，一个在夹具，另一个在 TYPED_TEST，以获取类型化参数。

在夹具中

  using T = typename std::tuple_element_t<0, Tup>;
  static constexpr std::size_t size = std::tuple_element_t<1, Tup>::value;
  using ClientT = typename Client<T, size>::ClientT;  // ClientT = std::array<T, size>

在 TYPED_TEST - ReturnTrueWhenComparedWithSameClientID

  using T = typename std::tuple_element<0, decltype(TypeParam())>::type;
  static constexpr std::size_t size = std::tuple_element_t<1, decltype(TypeParam())>::value;
  using ClientT = typename Client<T, size>::ClientT;  // std::array

客户

template <typename T, size_t size>
class Client {
 public:
  using ClientT = std::array<T, size>;

  Client(const ClientT& ID) : ID(ID) {}
  Client(const ClientT&& ID) : ID(std::move(ID)) {}

  inline const ClientT& getID() const { return ID; }
  inline bool isID(const ClientT& anotherID) const { return ID == anotherID; }

  inline bool operator==(const Client& anotherClient) { return ID == anotherClient.getID(); }

 private:
  ClientT ID;
};

单元测试文件是这样的

template <typename Tup>
class ClientTest : public testing::Test {
  using T = typename std::tuple_element_t<0, Tup>;
  static constexpr std::size_t size = std::tuple_element_t<1, Tup>::value;
  using ClientT = typename Client<T, size>::ClientT;  // ClientT = std::array<T, size>

 protected:
  ClientTest() : id(ClientT{1}), client(std::make_unique<Client<T, size>>(id)) {}
  ~ClientTest() override {}

  void setClient(const ClientT& id) { client.reset(new Client<T, size>(id)); }

  ClientT id;
  std::unique_ptr<Client<T, size>> client;
};

typedef testing::Types<std::tuple<std::int8_t, std::integral_constant<std::size_t, 16>>,
                       std::tuple<std::uint8_t, std::integral_constant<std::size_t, 24>>>
    Implementations;

TYPED_TEST_CASE(ClientTest, Implementations);

TYPED_TEST(ClientTest, ReturnTrueWhenComparedWithSameClientID) {
  using T = typename std::tuple_element<0, decltype(TypeParam())>::type;
  static constexpr std::size_t size = std::tuple_element_t<1, decltype(TypeParam())>::value;
  using ClientT = typename Client<T, size>::ClientT;  // std::array

  ClientT new_id{15};
  this->setClient(new_id);
  EXPECT_EQ(this->client->getID(), new_id);
  EXPECT_TRUE(this->client->isID(new_id));
}

到目前为止，测试正在编译并且看起来不错。但我不喜欢重复相同的代码块两次

我想知道是否有一种方法可以将数据类型和大小从夹具继承到 TYPED_TEST 中，或者比现有的更好。

谢谢

Answer 1

你可以做的是在夹具ClientTestpublic中创建别名ClientT

template <typename Tup>
class ClientTest : public testing::Test {
  public:
    using T = typename std::tuple_element_t<0, Tup>;
    static constexpr std::size_t size = std::tuple_element_t<1, Tup>::value;
    using ClientT = typename Client<T, size>::ClientT;
  protected:
    // ...
};

然后在TYPED_TEST 内部通过ClientTest<Tup>::ClientT 访问它（其中模板参数Tup 由TypeParam() 给出）

using ClientT = typename ClientTest<decltype(TypeParam())>::ClientT;

或从this指针获取模板类类型如下：

using ClientT = typename std::decay_t<decltype(*this)>::ClientT

如果您像上面的代码一样只需要一次，您甚至可能只使用

typename std::decay_t<decltype(*this)>::ClientT new_id{15};

Answer 2

从gtest引用documentation后

类型别名（using 或 typedef）在 TestFixture 中公开

template <typename Tup>
class ClientTest : public testing::Test {
public:
  using T = typename std::tuple_element_t<0, Tup>;
  static constexpr std::size_t size = std::tuple_element_t<1, Tup>::value;
  using ClientT = typename Client<T, size>::ClientT;  // ClientT = std::array<T, size>

 protected:
  ClientTest() : id(ClientT{1}), client(std::make_unique<Client<T, size>>(id)) {}
  ~ClientTest() override {}

  void setClient(const ClientT& id) { client.reset(new Client<T, size>(id)); }

  ClientT id;
  std::unique_ptr<Client<T, size>> client;
};

在 TYPED_TEST 中。类型别名（using 或 typedef）是从 TestFixture 范围 (TestFixture::) 解析的

TYPED_TEST(ClientTest, ReturnTrueWhenComparedWithSameClientID) {
  typename TestFixture::ClientT id{15};
}