// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMECAST_CAST_CORE_GRPC_STATUS_MATCHERS_H_
#define CHROMECAST_CAST_CORE_GRPC_STATUS_MATCHERS_H_
#include <string>
#include <type_traits>
#include "testing/gmock/include/gmock/gmock.h"
namespace cast {
namespace test {
namespace internal {
// Checks if a type T has a status() API helping distinguish if Status impl is
// nested inside T (eg GrpcStatusOr etc) or T is the Status impl.
template <typename T>
class has_status_api {
struct no {};
template <typename C>
static decltype(std::declval<C>().status()) test(int);
template <typename C>
static no test(...);
public:
enum { value = !std::is_same<decltype(test<T>(0)), no>::value };
};
// Checks if a Status impl has 'code' API deducing that status code and message
// can be retrieved using T::code() and T::message APIs (eg absl::Status).
template <typename T>
class has_code_api {
struct no {};
template <typename C>
static decltype(&C::code) test(int);
template <typename C>
static no test(...);
public:
enum { value = !std::is_same<decltype(test<T>(0)), no>::value };
};
// Checks if a Status impl has 'error_code' API deducing that status code and
// message can be retrieved using T::error_code() and T::error_message APIs (eg
// grpc::Status).
template <typename T>
class has_error_code_api {
struct no {};
template <typename C>
static decltype(&C::error_code) test(int);
template <typename C>
static no test(...);
public:
enum { value = !std::is_same<decltype(test<T>(0)), no>::value };
};
// Reads the error code and message of the generic TStatus which can be either a
// wrapper object with TStatus::status() defined or the actual status object
// with TStatus::code\message() or TStatus::error_code\error_message APIs. The
// resolution works based on SFINAE when invalid type substitution results in
// dropping the method from compilation.
class StatusResolver {
public:
struct StatusInfo {
int code;
std::string message;
};
// Constructor that deduces the actual APIs of TStatus and sets the code and
// message.
template <typename TStatus>
explicit StatusResolver(const TStatus& status)
: status_info_(ResolveStatusInfo(ResolveStatus(status))) {}
~StatusResolver();
// Returns the status code (as an integer) and message.
const StatusInfo& status_info() const { return status_info_; }
// Checks if status is ok.
bool ok() const { return status_info_.code == 0; }
private:
// Returns the actual status from the wrapper.
template <typename TWrappedStatus,
typename std::enable_if<has_status_api<TWrappedStatus>::value,
TWrappedStatus>::type* = nullptr>
static auto ResolveStatus(const TWrappedStatus& wrapped_status)
-> decltype(std::declval<const TWrappedStatus>().status()) {
return wrapped_status.status();
}
// Returns itself.
template <typename TStatus,
typename std::enable_if<!has_status_api<TStatus>::value,
TStatus>::type* = nullptr>
static auto ResolveStatus(const TStatus& status) -> TStatus {
return status;
}
// Returns the pair of integer code and error message using TStatus::code()
// and TStatus::message() APIs.
template <typename TStatus,
typename std::enable_if<has_code_api<TStatus>::value,
TStatus>::type* = nullptr>
static StatusInfo ResolveStatusInfo(const TStatus& status) {
return StatusInfo(
{static_cast<int>(status.code()), std::string(status.message())});
}
// Returns the pair of integer code and error message using
// TStatus::error_code() and TStatus::error_message() APIs.
template <typename TStatus,
typename std::enable_if<has_error_code_api<TStatus>::value,
TStatus>::type* = nullptr>
static StatusInfo ResolveStatusInfo(const TStatus& status) {
return StatusInfo({static_cast<int>(status.error_code()),
std::string(status.error_message())});
}
const StatusInfo status_info_;
};
// Implementation of MatcherInterface for StatusIs matcher.
template <typename TStatus>
class StatusIsImpl : public ::testing::MatcherInterface<TStatus> {
public:
StatusIsImpl(::testing::Matcher<int> code,
::testing::Matcher<std::string> message)
: code_(std::move(code)), message_(std::move(message)) {}
// MatcherInterface implementation.
void DescribeTo(std::ostream* os) const override {
*os << "has code() that ";
code_.DescribeTo(os);
*os << " and message() that ";
message_.DescribeTo(os);
}
void DescribeNegationTo(std::ostream* os) const override {
*os << "has code() that ";
code_.DescribeNegationTo(os);
*os << " and message() that ";
message_.DescribeNegationTo(os);
}
bool MatchAndExplain(
TStatus status,
::testing::MatchResultListener* result_listener) const override {
::testing::StringMatchResultListener listener;
StatusResolver status_resolver(status);
auto status_info = status_resolver.status_info();
if (!code_.Matches(status_info.code)) {
*result_listener << "has wrong status code " << status_info.code;
return false;
}
if (!message_.Matches(status_info.message)) {
*result_listener << "has wrong error message " << status_info.message;
return false;
}
return true;
}
private:
const ::testing::Matcher<int> code_;
const ::testing::Matcher<std::string> message_;
};
// Allows usage of StatusIs without template parameter
class StatusIsPolymorphicWrapper {
public:
template <typename TStatusCode>
StatusIsPolymorphicWrapper(TStatusCode code,
::testing::Matcher<std::string>&& message)
: code_(static_cast<int>(code)), message_(std::move(message)) {}
StatusIsPolymorphicWrapper(const StatusIsPolymorphicWrapper&);
~StatusIsPolymorphicWrapper();
// Converts this polymorphic matcher to a monomorphic matcher.
template <typename TStatus>
operator ::testing::Matcher<TStatus>() const {
return ::testing::Matcher<TStatus>(
new StatusIsImpl<TStatus>(std::move(code_), std::move(message_)));
}
private:
::testing::Matcher<int> code_;
::testing::Matcher<std::string> message_;
};
// Allows usage of IsOk without template parameter
template <typename TStatus>
class IsOkImpl : public ::testing::MatcherInterface<TStatus> {
public:
void DescribeTo(std::ostream* os) const override {
*os << "is OK";
} // namespace internal
void DescribeNegationTo(std::ostream* os) const override {
*os << "is not OK";
}
bool MatchAndExplain(TStatus actual_value,
::testing::MatchResultListener*) const override {
return StatusResolver(actual_value).ok();
}
}; // namespace test
class IsOkPolymorphicWrapper {
public:
template <typename TStatus>
operator ::testing::Matcher<TStatus>() const { // NOLINT
return ::testing::Matcher<TStatus>(new IsOkImpl<const TStatus&>());
}
};
} // namespace internal
template <typename TStatusCode>
inline internal::StatusIsPolymorphicWrapper StatusIs(TStatusCode code) {
return internal::StatusIsPolymorphicWrapper(code, ::testing::_);
}
template <typename TStatusCode>
inline internal::StatusIsPolymorphicWrapper StatusIs(
TStatusCode code,
::testing::Matcher<std::string>&& message_matcher) {
return internal::StatusIsPolymorphicWrapper(code, std::move(message_matcher));
}
inline internal::IsOkPolymorphicWrapper IsOk() {
return internal::IsOkPolymorphicWrapper();
}
#define CU_EXPECT_OK(expression) EXPECT_THAT(expression, ::cast::test::IsOk())
#define CU_ASSERT_OK(expression) ASSERT_THAT(expression, ::cast::test::IsOk())
#define CU_CHECK_OK(expression) \
CHECK(::cast::test::internal::StatusResolver(expression).ok())
} // namespace test
} // namespace cast
#endif // CHROMECAST_CAST_CORE_GRPC_STATUS_MATCHERS_H_
Codebase Browser
chromium