//
// The purpose of this file is to generate Google Test output under
// various conditions. The output will then be verified by
-// gtest_output_test.py to ensure that Google Test generates the
+// googletest-output-test.py to ensure that Google Test generates the
// desired messages. Therefore, most tests in this file are MEANT TO
// FAIL.
-//
-// Author: wan@google.com (Zhanyong Wan)
#include "gtest/gtest-spi.h"
#include "gtest/gtest.h"
-
-// Indicates that this translation unit is part of Google Test's
-// implementation. It must come before gtest-internal-inl.h is
-// included, or there will be a compiler error. This trick is to
-// prevent a user from accidentally including gtest-internal-inl.h in
-// his code.
-#define GTEST_IMPLEMENTATION_ 1
#include "src/gtest-internal-inl.h"
-#undef GTEST_IMPLEMENTATION_
#include <stdlib.h>
+#if _MSC_VER
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127 /* conditional expression is constant */)
+#endif // _MSC_VER
+
#if GTEST_IS_THREADSAFE
using testing::ScopedFakeTestPartResultReporter;
using testing::TestPartResultArray;
// This generates a test which will fail. Google Test is expected to print
// its parameter when it outputs the list of all failed tests.
-INSTANTIATE_TEST_CASE_P(PrintingFailingParams,
- FailingParamTest,
- testing::Values(2));
+INSTANTIATE_TEST_SUITE_P(PrintingFailingParams,
+ FailingParamTest,
+ testing::Values(2));
+
+// Tests that an empty value for the test suite basename yields just
+// the test name without any prior /
+class EmptyBasenameParamInst : public testing::TestWithParam<int> {};
+
+TEST_P(EmptyBasenameParamInst, Passes) { EXPECT_EQ(1, GetParam()); }
+
+INSTANTIATE_TEST_SUITE_P(, EmptyBasenameParamInst, testing::Values(1));
static const char kGoldenString[] = "\"Line\0 1\"\nLine 2";
SubWithoutTrace(n);
}
+TEST(SCOPED_TRACETest, AcceptedValues) {
+ SCOPED_TRACE("literal string");
+ SCOPED_TRACE(std::string("std::string"));
+ SCOPED_TRACE(1337); // streamable type
+ const char* null_value = nullptr;
+ SCOPED_TRACE(null_value);
+
+ ADD_FAILURE() << "Just checking that all these values work fine.";
+}
+
// Tests that SCOPED_TRACE() obeys lexical scopes.
TEST(SCOPED_TRACETest, ObeysScopes) {
printf("(expected to fail)\n");
printf("(expecting 6 failures)\n");
CheckPoints check_points;
- ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace,
- &check_points,
- NULL);
+ ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace, &check_points,
+ nullptr);
check_points.n1.WaitForNotification();
{
}
#endif // GTEST_IS_THREADSAFE
+// Tests basic functionality of the ScopedTrace utility (most of its features
+// are already tested in SCOPED_TRACETest).
+TEST(ScopedTraceTest, WithExplicitFileAndLine) {
+ testing::ScopedTrace trace("explicit_file.cc", 123, "expected trace message");
+ ADD_FAILURE() << "Check that the trace is attached to a particular location.";
+}
+
TEST(DisabledTestsWarningTest,
DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning) {
// This test body is intentionally empty. Its sole purpose is for
ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor.";
}
- ~NonFatalFailureInFixtureConstructorTest() {
+ ~NonFatalFailureInFixtureConstructorTest() override {
ADD_FAILURE() << "Expected failure #5, in the test fixture d'tor.";
}
- virtual void SetUp() {
- ADD_FAILURE() << "Expected failure #2, in SetUp().";
- }
+ void SetUp() override { ADD_FAILURE() << "Expected failure #2, in SetUp()."; }
- virtual void TearDown() {
+ void TearDown() override {
ADD_FAILURE() << "Expected failure #4, in TearDown.";
}
};
Init();
}
- ~FatalFailureInFixtureConstructorTest() {
+ ~FatalFailureInFixtureConstructorTest() override {
ADD_FAILURE() << "Expected failure #2, in the test fixture d'tor.";
}
- virtual void SetUp() {
+ void SetUp() override {
ADD_FAILURE() << "UNEXPECTED failure in SetUp(). "
<< "We should never get here, as the test fixture c'tor "
<< "had a fatal failure.";
}
- virtual void TearDown() {
+ void TearDown() override {
ADD_FAILURE() << "UNEXPECTED failure in TearDown(). "
<< "We should never get here, as the test fixture c'tor "
<< "had a fatal failure.";
// Tests non-fatal failures in SetUp().
class NonFatalFailureInSetUpTest : public testing::Test {
protected:
- virtual ~NonFatalFailureInSetUpTest() {
- Deinit();
- }
+ ~NonFatalFailureInSetUpTest() override { Deinit(); }
- virtual void SetUp() {
+ void SetUp() override {
printf("(expecting 4 failures)\n");
ADD_FAILURE() << "Expected failure #1, in SetUp().";
}
- virtual void TearDown() {
- FAIL() << "Expected failure #3, in TearDown().";
- }
+ void TearDown() override { FAIL() << "Expected failure #3, in TearDown()."; }
+
private:
void Deinit() {
FAIL() << "Expected failure #4, in the test fixture d'tor.";
// Tests fatal failures in SetUp().
class FatalFailureInSetUpTest : public testing::Test {
protected:
- virtual ~FatalFailureInSetUpTest() {
- Deinit();
- }
+ ~FatalFailureInSetUpTest() override { Deinit(); }
- virtual void SetUp() {
+ void SetUp() override {
printf("(expecting 3 failures)\n");
FAIL() << "Expected failure #1, in SetUp().";
}
- virtual void TearDown() {
- FAIL() << "Expected failure #2, in TearDown().";
- }
+ void TearDown() override { FAIL() << "Expected failure #2, in TearDown()."; }
+
private:
void Deinit() {
FAIL() << "Expected failure #3, in the test fixture d'tor.";
}
TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) {
- ADD_FAILURE_AT("foo.cc", 42) << "Expected failure in foo.cc";
+ ADD_FAILURE_AT("foo.cc", 42) << "Expected nonfatal failure in foo.cc";
+}
+
+TEST(GtestFailAtTest, MessageContainsSpecifiedFileAndLineNumber) {
+ GTEST_FAIL_AT("foo.cc", 42) << "Expected fatal failure in foo.cc";
}
#if GTEST_IS_THREADSAFE
class DeathTestAndMultiThreadsTest : public testing::Test {
protected:
// Starts a thread and waits for it to begin.
- virtual void SetUp() {
+ void SetUp() override {
thread_.reset(new ThreadWithParam<SpawnThreadNotifications*>(
- &ThreadRoutine, ¬ifications_, NULL));
+ &ThreadRoutine, ¬ifications_, nullptr));
notifications_.spawn_thread_started.WaitForNotification();
}
// Tells the thread to finish, and reaps it.
// a manager thread might still be left running that will interfere
// with later death tests. This is unfortunate, but this class
// cleans up after itself as best it can.
- virtual void TearDown() {
+ void TearDown() override {
notifications_.spawn_thread_ok_to_terminate.Notify();
}
private:
SpawnThreadNotifications notifications_;
- testing::internal::scoped_ptr<ThreadWithParam<SpawnThreadNotifications*> >
- thread_;
+ std::unique_ptr<ThreadWithParam<SpawnThreadNotifications*> > thread_;
};
#endif // GTEST_IS_THREADSAFE
-// The MixedUpTestCaseTest test case verifies that Google Test will fail a
+// The MixedUpTestSuiteTest test case verifies that Google Test will fail a
// test if it uses a different fixture class than what other tests in
// the same test case use. It deliberately contains two fixture
// classes with the same name but defined in different namespaces.
-// The MixedUpTestCaseWithSameTestNameTest test case verifies that
+// The MixedUpTestSuiteWithSameTestNameTest test case verifies that
// when the user defines two tests with the same test case name AND
// same test name (but in different namespaces), the second test will
// fail.
namespace foo {
-class MixedUpTestCaseTest : public testing::Test {
+class MixedUpTestSuiteTest : public testing::Test {
};
-TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {}
-TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {}
+TEST_F(MixedUpTestSuiteTest, FirstTestFromNamespaceFoo) {}
+TEST_F(MixedUpTestSuiteTest, SecondTestFromNamespaceFoo) {}
-class MixedUpTestCaseWithSameTestNameTest : public testing::Test {
+class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {
};
-TEST_F(MixedUpTestCaseWithSameTestNameTest,
+TEST_F(MixedUpTestSuiteWithSameTestNameTest,
TheSecondTestWithThisNameShouldFail) {}
} // namespace foo
namespace bar {
-class MixedUpTestCaseTest : public testing::Test {
+class MixedUpTestSuiteTest : public testing::Test {
};
// The following two tests are expected to fail. We rely on the
// golden file to check that Google Test generates the right error message.
-TEST_F(MixedUpTestCaseTest, ThisShouldFail) {}
-TEST_F(MixedUpTestCaseTest, ThisShouldFailToo) {}
+TEST_F(MixedUpTestSuiteTest, ThisShouldFail) {}
+TEST_F(MixedUpTestSuiteTest, ThisShouldFailToo) {}
-class MixedUpTestCaseWithSameTestNameTest : public testing::Test {
+class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {
};
// Expected to fail. We rely on the golden file to check that Google Test
// generates the right error message.
-TEST_F(MixedUpTestCaseWithSameTestNameTest,
+TEST_F(MixedUpTestSuiteWithSameTestNameTest,
TheSecondTestWithThisNameShouldFail) {}
} // namespace bar
// This #ifdef block tests the output of value-parameterized tests.
-#if GTEST_HAS_PARAM_TEST
-
std::string ParamNameFunc(const testing::TestParamInfo<std::string>& info) {
return info.param;
}
EXPECT_EQ("b", GetParam()) << "Expected failure";
}
-INSTANTIATE_TEST_CASE_P(PrintingStrings,
- ParamTest,
- testing::Values(std::string("a")),
- ParamNameFunc);
-
-#endif // GTEST_HAS_PARAM_TEST
+INSTANTIATE_TEST_SUITE_P(PrintingStrings,
+ ParamTest,
+ testing::Values(std::string("a")),
+ ParamNameFunc);
// This #ifdef block tests the output of typed tests.
#if GTEST_HAS_TYPED_TEST
class TypedTest : public testing::Test {
};
-TYPED_TEST_CASE(TypedTest, testing::Types<int>);
+TYPED_TEST_SUITE(TypedTest, testing::Types<int>);
TYPED_TEST(TypedTest, Success) {
EXPECT_EQ(0, TypeParam());
EXPECT_EQ(1, TypeParam()) << "Expected failure";
}
+typedef testing::Types<char, int> TypesForTestWithNames;
+
+template <typename T>
+class TypedTestWithNames : public testing::Test {};
+
+class TypedTestNames {
+ public:
+ template <typename T>
+ static std::string GetName(int i) {
+ if (std::is_same<T, char>::value)
+ return std::string("char") + ::testing::PrintToString(i);
+ if (std::is_same<T, int>::value)
+ return std::string("int") + ::testing::PrintToString(i);
+ }
+};
+
+TYPED_TEST_SUITE(TypedTestWithNames, TypesForTestWithNames, TypedTestNames);
+
+TYPED_TEST(TypedTestWithNames, Success) {}
+
+TYPED_TEST(TypedTestWithNames, Failure) { FAIL(); }
+
#endif // GTEST_HAS_TYPED_TEST
// This #ifdef block tests the output of type-parameterized tests.
class TypedTestP : public testing::Test {
};
-TYPED_TEST_CASE_P(TypedTestP);
+TYPED_TEST_SUITE_P(TypedTestP);
TYPED_TEST_P(TypedTestP, Success) {
EXPECT_EQ(0U, TypeParam());
EXPECT_EQ(1U, TypeParam()) << "Expected failure";
}
-REGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure);
+REGISTER_TYPED_TEST_SUITE_P(TypedTestP, Success, Failure);
typedef testing::Types<unsigned char, unsigned int> UnsignedTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes);
+INSTANTIATE_TYPED_TEST_SUITE_P(Unsigned, TypedTestP, UnsignedTypes);
+
+class TypedTestPNames {
+ public:
+ template <typename T>
+ static std::string GetName(int i) {
+ if (std::is_same<T, unsigned char>::value) {
+ return std::string("unsignedChar") + ::testing::PrintToString(i);
+ }
+ if (std::is_same<T, unsigned int>::value) {
+ return std::string("unsignedInt") + ::testing::PrintToString(i);
+ }
+ }
+};
+
+INSTANTIATE_TYPED_TEST_SUITE_P(UnsignedCustomName, TypedTestP, UnsignedTypes,
+ TypedTestPNames);
#endif // GTEST_HAS_TYPED_TEST_P
};
typedef testing::Types<int, double> NumericTypes;
-TYPED_TEST_CASE(ATypedDeathTest, NumericTypes);
+TYPED_TEST_SUITE(ATypedDeathTest, NumericTypes);
TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {
}
class ATypeParamDeathTest : public testing::Test {
};
-TYPED_TEST_CASE_P(ATypeParamDeathTest);
+TYPED_TEST_SUITE_P(ATypeParamDeathTest);
TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {
}
-REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst);
+REGISTER_TYPED_TEST_SUITE_P(ATypeParamDeathTest, ShouldRunFirst);
-INSTANTIATE_TYPED_TEST_CASE_P(My, ATypeParamDeathTest, NumericTypes);
+INSTANTIATE_TYPED_TEST_SUITE_P(My, ATypeParamDeathTest, NumericTypes);
# endif // GTEST_HAS_TYPED_TEST_P
class ExpectFailureWithThreadsTest : public ExpectFailureTest {
protected:
static void AddFailureInOtherThread(FailureMode failure) {
- ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);
+ ThreadWithParam<FailureMode> thread(&AddFailure, failure, nullptr);
thread.Join();
}
};
"Some other non-fatal failure.");
}
+class DynamicFixture : public testing::Test {
+ protected:
+ DynamicFixture() { printf("DynamicFixture()\n"); }
+ ~DynamicFixture() override { printf("~DynamicFixture()\n"); }
+ void SetUp() override { printf("DynamicFixture::SetUp\n"); }
+ void TearDown() override { printf("DynamicFixture::TearDown\n"); }
+
+ static void SetUpTestSuite() { printf("DynamicFixture::SetUpTestSuite\n"); }
+ static void TearDownTestSuite() {
+ printf("DynamicFixture::TearDownTestSuite\n");
+ }
+};
+
+template <bool Pass>
+class DynamicTest : public DynamicFixture {
+ public:
+ void TestBody() override { EXPECT_TRUE(Pass); }
+};
+
+auto dynamic_test = (
+ // Register two tests with the same fixture correctly.
+ testing::RegisterTest(
+ "DynamicFixture", "DynamicTestPass", nullptr, nullptr, __FILE__,
+ __LINE__, []() -> DynamicFixture* { return new DynamicTest<true>; }),
+ testing::RegisterTest(
+ "DynamicFixture", "DynamicTestFail", nullptr, nullptr, __FILE__,
+ __LINE__, []() -> DynamicFixture* { return new DynamicTest<false>; }),
+
+ // Register the same fixture with another name. That's fine.
+ testing::RegisterTest(
+ "DynamicFixtureAnotherName", "DynamicTestPass", nullptr, nullptr,
+ __FILE__, __LINE__,
+ []() -> DynamicFixture* { return new DynamicTest<true>; }),
+
+ // Register two tests with the same fixture incorrectly.
+ testing::RegisterTest(
+ "BadDynamicFixture1", "FixtureBase", nullptr, nullptr, __FILE__,
+ __LINE__, []() -> DynamicFixture* { return new DynamicTest<true>; }),
+ testing::RegisterTest(
+ "BadDynamicFixture1", "TestBase", nullptr, nullptr, __FILE__, __LINE__,
+ []() -> testing::Test* { return new DynamicTest<true>; }),
+
+ // Register two tests with the same fixture incorrectly by ommiting the
+ // return type.
+ testing::RegisterTest(
+ "BadDynamicFixture2", "FixtureBase", nullptr, nullptr, __FILE__,
+ __LINE__, []() -> DynamicFixture* { return new DynamicTest<true>; }),
+ testing::RegisterTest("BadDynamicFixture2", "Derived", nullptr, nullptr,
+ __FILE__, __LINE__,
+ []() { return new DynamicTest<true>; }));
// Two test environments for testing testing::AddGlobalTestEnvironment().
class FooEnvironment : public testing::Environment {
public:
- virtual void SetUp() {
- printf("%s", "FooEnvironment::SetUp() called.\n");
- }
+ void SetUp() override { printf("%s", "FooEnvironment::SetUp() called.\n"); }
- virtual void TearDown() {
+ void TearDown() override {
printf("%s", "FooEnvironment::TearDown() called.\n");
FAIL() << "Expected fatal failure.";
}
class BarEnvironment : public testing::Environment {
public:
- virtual void SetUp() {
- printf("%s", "BarEnvironment::SetUp() called.\n");
- }
+ void SetUp() override { printf("%s", "BarEnvironment::SetUp() called.\n"); }
- virtual void TearDown() {
+ void TearDown() override {
printf("%s", "BarEnvironment::TearDown() called.\n");
ADD_FAILURE() << "Expected non-fatal failure.";
}
// are registered, and torn down in the reverse order.
testing::AddGlobalTestEnvironment(new FooEnvironment);
testing::AddGlobalTestEnvironment(new BarEnvironment);
-
+#if _MSC_VER
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4127
+#endif // _MSC_VER
return RunAllTests();
}