1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Testing utilities that extend gtest.
#ifndef NET_TEST_GTEST_UTIL_H_
#define NET_TEST_GTEST_UTIL_H_
#include <string>
#include "base/strings/string_piece.h"
#include "base/test/mock_log.h"
#include "net/base/net_errors.h"
#include "net/test/scoped_disable_exit_on_dfatal.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net::test {
// A GMock matcher that checks whether the argument is the expected net::Error.
// On failure, the expected and actual net::Error names will be printed.
// Usage: EXPECT_THAT(foo(), IsError(net::ERR_INVALID_ARGUMENT));
MATCHER_P(IsError,
expected,
std::string(negation ? "not " : "") + net::ErrorToString(expected)) {
if (arg <= 0)
*result_listener << net::ErrorToString(arg);
return arg == expected;
}
// Shorthand for IsError(net::OK).
// Usage: EXPECT_THAT(foo(), IsOk());
MATCHER(IsOk,
std::string(negation ? "not " : "") + net::ErrorToString(net::OK)) {
if (arg <= 0)
*result_listener << net::ErrorToString(arg);
return arg == net::OK;
}
// A gMock matcher for base::StringPiece arguments.
// gMock's built-in HasSubstrMatcher does not work,
// because base::StringPiece cannot be implicitly converted to std::string.
class StringPieceHasSubstrMatcher {
public:
explicit StringPieceHasSubstrMatcher(const std::string& substring)
: substring_(substring) {}
StringPieceHasSubstrMatcher(const StringPieceHasSubstrMatcher&) = default;
StringPieceHasSubstrMatcher& operator=(const StringPieceHasSubstrMatcher&) =
default;
bool MatchAndExplain(base::StringPiece s,
::testing::MatchResultListener* listener) const {
return s.find(substring_) != std::string::npos;
}
// Describe what this matcher matches.
void DescribeTo(std::ostream* os) const {
*os << "has substring " << substring_;
}
void DescribeNegationTo(std::ostream* os) const {
*os << "has no substring " << substring_;
}
private:
std::string substring_;
};
// Internal implementation for the EXPECT_DFATAL and ASSERT_DFATAL
// macros. Do not use this directly.
#define GTEST_DFATAL_(statement, severity, matcher, fail) \
do { \
::base::test::MockLog gtest_log; \
::net::test::ScopedDisableExitOnDFatal gtest_disable_exit; \
using ::testing::_; \
EXPECT_CALL(gtest_log, Log(_, _, _, _, _)) \
.WillRepeatedly(::testing::Return(false)); \
EXPECT_CALL(gtest_log, Log(::logging::LOG_##severity, _, _, _, matcher)) \
.Times(::testing::AtLeast(1)) \
.WillOnce(::testing::Return(false)); \
gtest_log.StartCapturingLogs(); \
{ statement; } \
gtest_log.StopCapturingLogs(); \
if (!testing::Mock::VerifyAndClear(>est_log)) \
fail(""); \
} while (false)
// The EXPECT_DFATAL and ASSERT_DFATAL macros are lightweight
// alternatives to EXPECT_DEBUG_DEATH and ASSERT_DEBUG_DEATH. They
// are appropriate for testing that your code logs a message at the
// DFATAL level.
//
// Unlike EXPECT_DEBUG_DEATH and ASSERT_DEBUG_DEATH, these macros
// execute the given statement in the current process, not a forked
// one. This works because we disable exiting the program for
// LOG(DFATAL). This makes the tests run more quickly.
//
// The _WITH() variants allow one to specify any matcher for the
// DFATAL log message, whereas the other variants assume a regex.
#define EXPECT_DFATAL_WITH(statement, matcher) \
GTEST_DFATAL_(statement, DFATAL, matcher, GTEST_NONFATAL_FAILURE_)
#define ASSERT_DFATAL_WITH(statement, matcher) \
GTEST_DFATAL_(statement, DFATAL, matcher, GTEST_FATAL_FAILURE_)
#define EXPECT_DFATAL(statement, regex) \
EXPECT_DFATAL_WITH(statement, ::testing::ContainsRegex(regex))
#define ASSERT_DFATAL(statement, regex) \
ASSERT_DFATAL_WITH(statement, ::testing::ContainsRegex(regex))
// The EXPECT_DEBUG_DFATAL and ASSERT_DEBUG_DFATAL macros are similar to
// EXPECT_DFATAL and ASSERT_DFATAL. Use them in conjunction with DLOG(DFATAL)
// or similar macros that produce no-op in opt build and DFATAL in dbg build.
#ifndef NDEBUG
#define EXPECT_DEBUG_DFATAL(statement, regex) \
EXPECT_DFATAL(statement, regex)
#define ASSERT_DEBUG_DFATAL(statement, regex) \
ASSERT_DFATAL(statement, regex)
#else // NDEBUG
#define EXPECT_DEBUG_DFATAL(statement, regex) \
do { \
(void)(regex); \
statement; \
} while (false)
#define ASSERT_DEBUG_DFATAL(statement, regex) \
do { \
(void)(regex); \
statement; \
} while (false)
#endif // NDEBUG
// The EXPECT_DCHECK and ASSERT_DCHECK macros are similar to EXPECT_DFATAL and
// ASSERT_DFATAL. Use them in conjunction with DCHECK that produces no-op in opt
// build and LOG_DCHECK (FATAL) if DCHECK_IS_ON().
#if DCHECK_IS_ON()
#define EXPECT_DCHECK(statement, regex) \
GTEST_DFATAL_(statement, DCHECK, ::testing::ContainsRegex(regex), \
GTEST_NONFATAL_FAILURE_)
#define ASSERT_DCHECK(statement, regex) \
GTEST_DFATAL_(statement, DCHECK, ::testing::ContainsRegex(regex), \
GTEST_FATAL_FAILURE_)
#else // DCHECK_IS_ON()
#define EXPECT_DCHECK(statement, regex) \
do { \
(void)(regex); \
statement; \
} while (false)
#define ASSERT_DCHECK(statement, regex) \
do { \
(void)(regex); \
statement; \
} while (false)
#endif // DCHECK_IS_ON()
} // namespace net::test
#endif // NET_TEST_GTEST_UTIL_H_
|