56#define GTEST_IMPLEMENTATION_ 1
58#undef GTEST_IMPLEMENTATION_
61# include <sys/types.h>
73TEST(JoinAsTupleTest, JoinsEmptyTuple) {
77TEST(JoinAsTupleTest, JoinsOneTuple) {
78 const char* fields[] = {
"1"};
82TEST(JoinAsTupleTest, JoinsTwoTuple) {
83 const char* fields[] = {
"1",
"a"};
87TEST(JoinAsTupleTest, JoinsTenTuple) {
88 const char* fields[] = {
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"10"};
89 EXPECT_EQ(
"(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)",
93TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
99TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) {
106TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) {
114TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) {
121TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
127TEST(PointeeOfTest, WorksForSmartPointers) {
129 (std::is_same<
int, PointeeOf<std::unique_ptr<int>>::type>
::value));
131 (std::is_same<std::string,
132 PointeeOf<std::shared_ptr<std::string>>::type>
::value));
135TEST(PointeeOfTest, WorksForRawPointers) {
141TEST(GetRawPointerTest, WorksForSmartPointers) {
142 const char*
const raw_p1 =
new const char(
'a');
143 const std::unique_ptr<const char> p1(raw_p1);
145 double*
const raw_p2 =
new double(2.5);
146 const std::shared_ptr<double> p2(raw_p2);
150TEST(GetRawPointerTest, WorksForRawPointers) {
160class Derived :
public Base {};
166TEST(KindOfTest, Integer) {
180#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
186TEST(KindOfTest, FloatingPoint) {
192TEST(KindOfTest, Other) {
200TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
201 EXPECT_TRUE((LosslessArithmeticConvertible<bool, bool>::value));
204TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
205 EXPECT_TRUE((LosslessArithmeticConvertible<bool, char>::value));
206 EXPECT_TRUE((LosslessArithmeticConvertible<bool, int>::value));
208 (LosslessArithmeticConvertible<bool, unsigned long>::value));
211TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
212 EXPECT_TRUE((LosslessArithmeticConvertible<bool, float>::value));
213 EXPECT_TRUE((LosslessArithmeticConvertible<bool, double>::value));
216TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
217 EXPECT_FALSE((LosslessArithmeticConvertible<unsigned char, bool>::value));
218 EXPECT_FALSE((LosslessArithmeticConvertible<int, bool>::value));
221TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
223 EXPECT_TRUE((LosslessArithmeticConvertible<unsigned char, int>::value));
227 unsigned short, uint64_t>
::value));
233 signed char,
unsigned int>
::value));
237 unsigned char,
unsigned char>
::value));
238 EXPECT_TRUE((LosslessArithmeticConvertible<int, int>::value));
239 EXPECT_TRUE((LosslessArithmeticConvertible<wchar_t, wchar_t>::value));
241 unsigned long,
unsigned long>
::value));
245 unsigned char,
signed char>
::value));
246 EXPECT_FALSE((LosslessArithmeticConvertible<int, unsigned int>::value));
247 EXPECT_FALSE((LosslessArithmeticConvertible<uint64_t, int64_t>::value));
250 EXPECT_FALSE((LosslessArithmeticConvertible<long, char>::value));
251 EXPECT_FALSE((LosslessArithmeticConvertible<int, signed char>::value));
252 EXPECT_FALSE((LosslessArithmeticConvertible<int64_t, unsigned int>::value));
255TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
258 EXPECT_FALSE((LosslessArithmeticConvertible<char, float>::value));
259 EXPECT_FALSE((LosslessArithmeticConvertible<int, double>::value));
264TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
265 EXPECT_FALSE((LosslessArithmeticConvertible<float, bool>::value));
266 EXPECT_FALSE((LosslessArithmeticConvertible<double, bool>::value));
269TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
270 EXPECT_FALSE((LosslessArithmeticConvertible<float, long>::value));
271 EXPECT_FALSE((LosslessArithmeticConvertible<double, int64_t>::value));
272 EXPECT_FALSE((LosslessArithmeticConvertible<long double, int>::value));
275TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
277 EXPECT_TRUE((LosslessArithmeticConvertible<float, double>::value));
278 EXPECT_TRUE((LosslessArithmeticConvertible<float, long double>::value));
279 EXPECT_TRUE((LosslessArithmeticConvertible<double, long double>::value));
282 EXPECT_TRUE((LosslessArithmeticConvertible<float, float>::value));
283 EXPECT_TRUE((LosslessArithmeticConvertible<double, double>::value));
286 EXPECT_FALSE((LosslessArithmeticConvertible<double, float>::value));
288 if (sizeof(
double) == sizeof(
long double)) {
294 EXPECT_FALSE((LosslessArithmeticConvertible<long double, double>::value));
300TEST(TupleMatchesTest, WorksForSize0) {
301 std::tuple<> matchers;
307TEST(TupleMatchesTest, WorksForSize1) {
308 std::tuple<Matcher<int> > matchers(Eq(1));
309 std::tuple<int> values1(1), values2(2);
315TEST(TupleMatchesTest, WorksForSize2) {
316 std::tuple<Matcher<int>, Matcher<char> > matchers(Eq(1), Eq(
'a'));
317 std::tuple<int, char> values1(1,
'a'), values2(1,
'b'), values3(2,
'a'),
326TEST(TupleMatchesTest, WorksForSize5) {
327 std::tuple<Matcher<int>, Matcher<char>, Matcher<bool>,
329 Matcher<std::string> >
330 matchers(Eq(1), Eq(
'a'), Eq(
true), Eq(2L), Eq(
"hi"));
331 std::tuple<int, char, bool, long, std::string>
332 values1(1,
'a',
true, 2L,
"hi"), values2(1,
'a',
true, 2L,
"hello"),
333 values3(2,
'a',
true, 2L,
"hi");
341TEST(AssertTest, SucceedsOnTrue) {
342 Assert(
true, __FILE__, __LINE__,
"This should succeed.");
343 Assert(
true, __FILE__, __LINE__);
347TEST(AssertTest, FailsFatallyOnFalse) {
349 Assert(
false, __FILE__, __LINE__,
"This should fail.");
353 Assert(
false, __FILE__, __LINE__);
358TEST(ExpectTest, SucceedsOnTrue) {
359 Expect(
true, __FILE__, __LINE__,
"This should succeed.");
360 Expect(
true, __FILE__, __LINE__);
364TEST(ExpectTest, FailsNonfatallyOnFalse) {
366 Expect(
false, __FILE__, __LINE__,
"This should fail.");
367 },
"This should fail");
370 Expect(
false, __FILE__, __LINE__);
371 },
"Expectation failed");
385TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
391TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
397TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
403#if GTEST_HAS_STREAM_REDIRECTION
409void TestLogWithSeverity(
const std::string& verbosity,
LogSeverity severity,
411 const std::string old_flag =
GMOCK_FLAG(verbose);
414 Log(severity,
"Test log.\n", 0);
419 "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" :
420 "^\nTest log\\.\nStack trace:\n"));
429TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
430 const std::string saved_flag =
GMOCK_FLAG(verbose);
434 EXPECT_STREQ(
"\nTest log.\n", GetCapturedStdout().c_str());
438struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface {
439 std::string CurrentStackTrace(
int max_depth,
int skip_count)
override {
443 void UponLeavingGTest()
override {}
448TEST(LogTest, NoSkippingStackFrameInOptMode) {
449 MockStackTraceGetter* mock_os_stack_trace_getter =
new MockStackTraceGetter;
450 GetUnitTestImpl()->set_os_stack_trace_getter(mock_os_stack_trace_getter);
454 const std::string log = GetCapturedStdout();
456 std::string expected_trace =
458 std::string expected_message =
464 int skip_count = atoi(log.substr(expected_message.size()).c_str());
468 const int expected_skip_count = 0;
471 const int expected_skip_count = 100;
478 AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10)));
481 GetUnitTestImpl()->set_os_stack_trace_getter(
nullptr);
486TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
487 TestLogWithSeverity(kInfoVerbosity,
kInfo,
true);
488 TestLogWithSeverity(kInfoVerbosity,
kWarning,
true);
493TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) {
494 TestLogWithSeverity(kWarningVerbosity,
kInfo,
false);
495 TestLogWithSeverity(kWarningVerbosity,
kWarning,
true);
500TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) {
501 TestLogWithSeverity(kErrorVerbosity,
kInfo,
false);
502 TestLogWithSeverity(kErrorVerbosity,
kWarning,
false);
507TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
508 TestLogWithSeverity(
"invalid",
kInfo,
false);
509 TestLogWithSeverity(
"invalid",
kWarning,
true);
514std::string GrabOutput(
void(*logger)(),
const char* verbosity) {
515 const std::string saved_flag =
GMOCK_FLAG(verbose);
520 return GetCapturedStdout();
529void ExpectCallLogger() {
536TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
537 EXPECT_THAT(std::string(GrabOutput(ExpectCallLogger, kInfoVerbosity)),
538 HasSubstr(
"EXPECT_CALL(mock, TestMethod())"));
543TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
544 EXPECT_STREQ(
"", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str());
549TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) {
550 EXPECT_STREQ(
"", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
559TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
560 EXPECT_THAT(std::string(GrabOutput(OnCallLogger, kInfoVerbosity)),
561 HasSubstr(
"ON_CALL(mock, TestMethod())"));
566TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
567 EXPECT_STREQ(
"", GrabOutput(OnCallLogger, kWarningVerbosity).c_str());
572TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
573 EXPECT_STREQ(
"", GrabOutput(OnCallLogger, kErrorVerbosity).c_str());
576void OnCallAnyArgumentLogger() {
578 ON_CALL(mock, TestMethodArg(_));
582TEST(OnCallTest, LogsAnythingArgument) {
583 EXPECT_THAT(std::string(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity)),
584 HasSubstr(
"ON_CALL(mock, TestMethodArg(_)"));
591TEST(StlContainerViewTest, WorksForStlContainer) {
592 StaticAssertTypeEq<std::vector<int>,
593 StlContainerView<std::vector<int> >::type>();
594 StaticAssertTypeEq<const std::vector<double>&,
595 StlContainerView<std::vector<double> >::const_reference>();
597 typedef std::vector<char> Chars;
607TEST(StlContainerViewTest, WorksForStaticNativeArray) {
608 StaticAssertTypeEq<NativeArray<int>,
610 StaticAssertTypeEq<NativeArray<double>,
612 StaticAssertTypeEq<NativeArray<char[3]>,
615 StaticAssertTypeEq<const NativeArray<int>,
618 int a1[3] = { 0, 1, 2 };
634TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
635 StaticAssertTypeEq<NativeArray<int>,
636 StlContainerView<std::tuple<const int*, size_t> >::type>();
639 StlContainerView<std::tuple<std::shared_ptr<double>,
int> >::type>();
642 const NativeArray<int>,
643 StlContainerView<std::tuple<const int*, int> >::const_reference>();
645 int a1[3] = { 0, 1, 2 };
646 const int*
const p1 = a1;
647 NativeArray<int> a2 =
648 StlContainerView<std::tuple<const int*, int> >::ConstReference(
649 std::make_tuple(p1, 3));
653 const NativeArray<int> a3 = StlContainerView<std::tuple<int*, size_t> >::Copy(
654 std::make_tuple(
static_cast<int*
>(a1), 3));
667TEST(FunctionTest, Nullary) {
668 typedef Function<int()>
F;
670 EXPECT_TRUE((std::is_same<int, F::Result>::value));
677TEST(FunctionTest, Unary) {
678 typedef Function<int(
bool)>
F;
680 EXPECT_TRUE((std::is_same<int, F::Result>::value));
684 std::is_same<std::tuple<Matcher<bool>>, F::ArgumentMatcherTuple>
::value));
687 F::MakeResultIgnoredValue>
::value));
690TEST(FunctionTest, Binary) {
691 typedef Function<int(
bool,
const long&)>
F;
693 EXPECT_TRUE((std::is_same<int, F::Result>::value));
696 EXPECT_TRUE((std::is_same<std::tuple<bool, const long&>,
699 (std::is_same<std::tuple<Matcher<bool>, Matcher<const long&>>,
700 F::ArgumentMatcherTuple>
::value));
703 EXPECT_TRUE((std::is_same<IgnoredValue(
bool,
const long&),
704 F::MakeResultIgnoredValue>
::value));
707TEST(FunctionTest, LongArgumentList) {
708 typedef Function<char(
bool,
int,
char*,
int&,
const long&)>
F;
710 EXPECT_TRUE((std::is_same<char, F::Result>::value));
717 (std::is_same<std::tuple<bool, int, char*, int&, const long&>,
721 std::tuple<Matcher<bool>, Matcher<int>, Matcher<char*>, Matcher<int&>,
722 Matcher<const long&>>,
723 F::ArgumentMatcherTuple>
::value));
725 (std::is_same<
void(
bool,
int,
char*,
int&,
const long&),
728 std::is_same<IgnoredValue(
bool,
int,
char*,
int&,
const long&),
729 F::MakeResultIgnoredValue>
::value));
static const_reference ConstReference(const RawContainer &container)
static type Copy(const RawContainer &container)
const type & const_reference
#define MOCK_METHOD0(m,...)
#define MOCK_METHOD1(m,...)
#define GMOCK_KIND_OF_(type)
std::string original_verbose_
#define EXPECT_THAT(value, matcher)
#define EXPECT_CALL(obj, call)
#define ON_CALL(obj, call)
#define EXPECT_DEATH_IF_SUPPORTED(statement, regex)
#define GTEST_INTENTIONAL_CONST_COND_PUSH_()
#define GTEST_INTENTIONAL_CONST_COND_POP_()
#define EXPECT_NONFATAL_FAILURE(statement, substr)
#define TEST_F(test_fixture, test_name)
#define ASSERT_EQ(val1, val2)
#define EXPECT_EQ(val1, val2)
#define TEST(test_suite_name, test_name)
#define EXPECT_TRUE(condition)
#define EXPECT_STREQ(s1, s2)
#define EXPECT_FALSE(condition)
GTEST_API_ std::string ConvertIdentifierNameToWords(const char *id_name)
const char kErrorVerbosity[]
GTEST_API_ std::string JoinAsTuple(const Strings &fields)
::std::vector< ::std::string > Strings
GTEST_API_ bool LogIsVisible(LogSeverity severity)
GTEST_API_ void Log(LogSeverity severity, const std::string &message, int stack_frames_to_skip)
const char kInfoVerbosity[]
void Assert(bool condition, const char *file, int line, const std::string &msg)
const Pointer::element_type * GetRawPointer(const Pointer &p)
void Expect(bool condition, const char *file, int line, const std::string &msg)
const char kWarningVerbosity[]
LosslessArithmeticConvertibleImpl< GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To > LosslessArithmeticConvertible
Pointer::element_type type