From 9b093c1779eb48a55db026cfd525f4cf1bbd4749 Mon Sep 17 00:00:00 2001 From: shiqian Date: Wed, 6 Aug 2008 21:43:15 +0000 Subject: Cleans up the usage of testing:: in gtest_unittest. By Zhanyong Wan. --- test/gtest_unittest.cc | 313 ++++++++++++++++++++++--------------------------- 1 file changed, 143 insertions(+), 170 deletions(-) (limited to 'test') diff --git a/test/gtest_unittest.cc b/test/gtest_unittest.cc index 374f7c14..9f1cbe97 100644 --- a/test/gtest_unittest.cc +++ b/test/gtest_unittest.cc @@ -74,17 +74,38 @@ bool ShouldUseColor(bool stdout_is_tty); } // namespace internal } // namespace testing +using testing::AssertionFailure; +using testing::AssertionResult; +using testing::AssertionSuccess; +using testing::DoubleLE; +using testing::FloatLE; +using testing::GTEST_FLAG(break_on_failure); +using testing::GTEST_FLAG(catch_exceptions); using testing::GTEST_FLAG(color); +using testing::GTEST_FLAG(filter); +using testing::GTEST_FLAG(list_tests); +using testing::GTEST_FLAG(output); +using testing::GTEST_FLAG(print_time); +using testing::GTEST_FLAG(repeat); +using testing::GTEST_FLAG(show_internal_stack_frames); +using testing::GTEST_FLAG(stack_trace_depth); +using testing::IsNotSubstring; +using testing::IsSubstring; +using testing::Message; using testing::ScopedFakeTestPartResultReporter; +using testing::Test; using testing::TestPartResult; using testing::TestPartResultArray; +using testing::TPRT_FATAL_FAILURE; +using testing::TPRT_NONFATAL_FAILURE; +using testing::TPRT_SUCCESS; using testing::UnitTest; using testing::internal::AppendUserMessage; using testing::internal::EqFailure; +using testing::internal::FloatingPoint; +using testing::internal::GTestFlagSaver; using testing::internal::Int32; using testing::internal::List; -using testing::internal::OsStackTraceGetter; -using testing::internal::OsStackTraceGetterInterface; using testing::internal::ShouldUseColor; using testing::internal::StreamableToString; using testing::internal::String; @@ -92,7 +113,6 @@ using testing::internal::TestProperty; using testing::internal::TestResult; using testing::internal::ToUtf8String; using testing::internal::UnitTestImpl; -using testing::internal::UnitTestOptions; // This line tests that we can define tests in an unnamed namespace. namespace { @@ -489,30 +509,21 @@ TEST(TestPropertyTest, ReplaceStringValue) { // Tests the TestPartResult class. // The test fixture for testing TestPartResult. -class TestPartResultTest : public testing::Test { +class TestPartResultTest : public Test { protected: TestPartResultTest() - : r1_(testing::TPRT_SUCCESS, - "foo/bar.cc", - 10, - "Success!"), - r2_(testing::TPRT_NONFATAL_FAILURE, - "foo/bar.cc", - -1, - "Failure!"), - r3_(testing::TPRT_FATAL_FAILURE, - NULL, - -1, - "Failure!") {} + : r1_(TPRT_SUCCESS, "foo/bar.cc", 10, "Success!"), + r2_(TPRT_NONFATAL_FAILURE, "foo/bar.cc", -1, "Failure!"), + r3_(TPRT_FATAL_FAILURE, NULL, -1, "Failure!") {} TestPartResult r1_, r2_, r3_; }; // Tests TestPartResult::type() TEST_F(TestPartResultTest, type) { - EXPECT_EQ(testing::TPRT_SUCCESS, r1_.type()); - EXPECT_EQ(testing::TPRT_NONFATAL_FAILURE, r2_.type()); - EXPECT_EQ(testing::TPRT_FATAL_FAILURE, r3_.type()); + EXPECT_EQ(TPRT_SUCCESS, r1_.type()); + EXPECT_EQ(TPRT_NONFATAL_FAILURE, r2_.type()); + EXPECT_EQ(TPRT_FATAL_FAILURE, r3_.type()); } // Tests TestPartResult::file_name() @@ -562,17 +573,11 @@ TEST_F(TestPartResultTest, NonfatallyFailed) { // Tests the TestPartResultArray class. -class TestPartResultArrayTest : public testing::Test { +class TestPartResultArrayTest : public Test { protected: TestPartResultArrayTest() - : r1_(testing::TPRT_NONFATAL_FAILURE, - "foo/bar.cc", - -1, - "Failure 1"), - r2_(testing::TPRT_FATAL_FAILURE, - "foo/bar.cc", - -1, - "Failure 2") {} + : r1_(TPRT_NONFATAL_FAILURE, "foo/bar.cc", -1, "Failure 1"), + r2_(TPRT_FATAL_FAILURE, "foo/bar.cc", -1, "Failure 2") {} const TestPartResult r1_, r2_; }; @@ -625,7 +630,7 @@ TEST(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) { // Tests the TestResult class // The test fixture for testing TestResult. -class TestResultTest : public testing::Test { +class TestResultTest : public Test { protected: typedef List TPRList; @@ -637,16 +642,12 @@ class TestResultTest : public testing::Test { virtual void SetUp() { // pr1 is for success. - pr1 = new TestPartResult(testing::TPRT_SUCCESS, - "foo/bar.cc", - 10, - "Success!"); + pr1 = new TestPartResult(TPRT_SUCCESS, "foo/bar.cc", 10, "Success!"); // pr2 is for fatal failure. - pr2 = new TestPartResult(testing::TPRT_FATAL_FAILURE, - "foo/bar.cc", - -1, // This line number means "unknown" - "Failure!"); + pr2 = new TestPartResult(TPRT_FATAL_FAILURE, "foo/bar.cc", + -1, // This line number means "unknown" + "Failure!"); // Creates the TestResult objects. r0 = new TestResult(); @@ -821,22 +822,22 @@ TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledClassname) { // Tests that GTestFlagSaver works on Windows and Mac. -class GTestFlagSaverTest : public testing::Test { +class GTestFlagSaverTest : public Test { protected: // Saves the Google Test flags such that we can restore them later, and // then sets them to their default values. This will be called // before the first test in this test case is run. static void SetUpTestCase() { - saver_ = new testing::internal::GTestFlagSaver; - - testing::GTEST_FLAG(break_on_failure) = false; - testing::GTEST_FLAG(catch_exceptions) = false; - testing::GTEST_FLAG(color) = "auto"; - testing::GTEST_FLAG(filter) = ""; - testing::GTEST_FLAG(list_tests) = false; - testing::GTEST_FLAG(output) = ""; - testing::GTEST_FLAG(print_time) = false; - testing::GTEST_FLAG(repeat) = 1; + saver_ = new GTestFlagSaver; + + GTEST_FLAG(break_on_failure) = false; + GTEST_FLAG(catch_exceptions) = false; + GTEST_FLAG(color) = "auto"; + GTEST_FLAG(filter) = ""; + GTEST_FLAG(list_tests) = false; + GTEST_FLAG(output) = ""; + GTEST_FLAG(print_time) = false; + GTEST_FLAG(repeat) = 1; } // Restores the Google Test flags that the tests have modified. This will @@ -849,30 +850,30 @@ class GTestFlagSaverTest : public testing::Test { // Verifies that the Google Test flags have their default values, and then // modifies each of them. void VerifyAndModifyFlags() { - EXPECT_FALSE(testing::GTEST_FLAG(break_on_failure)); - EXPECT_FALSE(testing::GTEST_FLAG(catch_exceptions)); - EXPECT_STREQ("auto", testing::GTEST_FLAG(color).c_str()); - EXPECT_STREQ("", testing::GTEST_FLAG(filter).c_str()); - EXPECT_FALSE(testing::GTEST_FLAG(list_tests)); - EXPECT_STREQ("", testing::GTEST_FLAG(output).c_str()); - EXPECT_FALSE(testing::GTEST_FLAG(print_time)); - EXPECT_EQ(1, testing::GTEST_FLAG(repeat)); - - testing::GTEST_FLAG(break_on_failure) = true; - testing::GTEST_FLAG(catch_exceptions) = true; - testing::GTEST_FLAG(color) = "no"; - testing::GTEST_FLAG(filter) = "abc"; - testing::GTEST_FLAG(list_tests) = true; - testing::GTEST_FLAG(output) = "xml:foo.xml"; - testing::GTEST_FLAG(print_time) = true; - testing::GTEST_FLAG(repeat) = 100; + EXPECT_FALSE(GTEST_FLAG(break_on_failure)); + EXPECT_FALSE(GTEST_FLAG(catch_exceptions)); + EXPECT_STREQ("auto", GTEST_FLAG(color).c_str()); + EXPECT_STREQ("", GTEST_FLAG(filter).c_str()); + EXPECT_FALSE(GTEST_FLAG(list_tests)); + EXPECT_STREQ("", GTEST_FLAG(output).c_str()); + EXPECT_FALSE(GTEST_FLAG(print_time)); + EXPECT_EQ(1, GTEST_FLAG(repeat)); + + GTEST_FLAG(break_on_failure) = true; + GTEST_FLAG(catch_exceptions) = true; + GTEST_FLAG(color) = "no"; + GTEST_FLAG(filter) = "abc"; + GTEST_FLAG(list_tests) = true; + GTEST_FLAG(output) = "xml:foo.xml"; + GTEST_FLAG(print_time) = true; + GTEST_FLAG(repeat) = 100; } private: // For saving Google Test flags during this test case. - static testing::internal::GTestFlagSaver* saver_; + static GTestFlagSaver* saver_; }; -testing::internal::GTestFlagSaver* GTestFlagSaverTest::saver_ = NULL; +GTestFlagSaver* GTestFlagSaverTest::saver_ = NULL; // Google Test doesn't guarantee the order of tests. The following two // tests are designed to work regardless of their order. @@ -896,7 +897,7 @@ static void SetEnv(const char* name, const char* value) { // Environment variables are not supported on Windows CE. return; #elif defined(GTEST_OS_WINDOWS) // If we are on Windows proper. - _putenv((testing::Message() << name << "=" << value).GetString().c_str()); + _putenv((Message() << name << "=" << value).GetString().c_str()); #else if (*value == '\0') { unsetenv(name); @@ -909,7 +910,7 @@ static void SetEnv(const char* name, const char* value) { #ifndef _WIN32_WCE // Environment variables are not supported on Windows CE. -using ::testing::internal::Int32FromGTestEnv; +using testing::internal::Int32FromGTestEnv; // Tests Int32FromGTestEnv(). @@ -1037,20 +1038,20 @@ struct IsEvenFunctor { // A predicate-formatter function that asserts the argument is an even // number. -testing::AssertionResult AssertIsEven(const char* expr, int n) { +AssertionResult AssertIsEven(const char* expr, int n) { if (IsEven(n)) { - return testing::AssertionSuccess(); + return AssertionSuccess(); } - testing::Message msg; + Message msg; msg << expr << " evaluates to " << n << ", which is not even."; - return testing::AssertionFailure(msg); + return AssertionFailure(msg); } // A predicate-formatter functor that asserts the argument is an even // number. struct AssertIsEvenFunctor { - testing::AssertionResult operator()(const char* expr, int n) { + AssertionResult operator()(const char* expr, int n) { return AssertIsEven(expr, n); } }; @@ -1070,50 +1071,38 @@ struct SumIsEven3Functor { // A predicate-formatter function that asserts the sum of the // arguments is an even number. -testing::AssertionResult AssertSumIsEven4(const char* e1, - const char* e2, - const char* e3, - const char* e4, - int n1, - int n2, - int n3, - int n4) { +AssertionResult AssertSumIsEven4( + const char* e1, const char* e2, const char* e3, const char* e4, + int n1, int n2, int n3, int n4) { const int sum = n1 + n2 + n3 + n4; if (IsEven(sum)) { - return testing::AssertionSuccess(); + return AssertionSuccess(); } - testing::Message msg; + Message msg; msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 << ") evaluates to " << sum << ", which is not even."; - return testing::AssertionFailure(msg); + return AssertionFailure(msg); } // A predicate-formatter functor that asserts the sum of the arguments // is an even number. struct AssertSumIsEven5Functor { - testing::AssertionResult operator()(const char* e1, - const char* e2, - const char* e3, - const char* e4, - const char* e5, - int n1, - int n2, - int n3, - int n4, - int n5) { + AssertionResult operator()( + const char* e1, const char* e2, const char* e3, const char* e4, + const char* e5, int n1, int n2, int n3, int n4, int n5) { const int sum = n1 + n2 + n3 + n4 + n5; if (IsEven(sum)) { - return testing::AssertionSuccess(); + return AssertionSuccess(); } - testing::Message msg; + Message msg; msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5 << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5 << ") evaluates to " << sum << ", which is not even."; - return testing::AssertionFailure(msg); + return AssertionFailure(msg); } }; @@ -1294,27 +1283,27 @@ TEST(PredicateAssertionTest, AcceptsTemplateFunction) { // Some helper functions for testing using overloaded/template // functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn. -testing::AssertionResult IsPositiveFormat(const char* expr, int n) { - return n > 0 ? testing::AssertionSuccess() : - testing::AssertionFailure(testing::Message() << "Failure"); +AssertionResult IsPositiveFormat(const char* expr, int n) { + return n > 0 ? AssertionSuccess() : + AssertionFailure(Message() << "Failure"); } -testing::AssertionResult IsPositiveFormat(const char* expr, double x) { - return x > 0 ? testing::AssertionSuccess() : - testing::AssertionFailure(testing::Message() << "Failure"); +AssertionResult IsPositiveFormat(const char* expr, double x) { + return x > 0 ? AssertionSuccess() : + AssertionFailure(Message() << "Failure"); } template -testing::AssertionResult IsNegativeFormat(const char* expr, T x) { - return x < 0 ? testing::AssertionSuccess() : - testing::AssertionFailure(testing::Message() << "Failure"); +AssertionResult IsNegativeFormat(const char* expr, T x) { + return x < 0 ? AssertionSuccess() : + AssertionFailure(Message() << "Failure"); } template -testing::AssertionResult EqualsFormat(const char* expr1, const char* expr2, - const T1& x1, const T2& x2) { - return x1 == x2 ? testing::AssertionSuccess() : - testing::AssertionFailure(testing::Message() << "Failure"); +AssertionResult EqualsFormat(const char* expr1, const char* expr2, + const T1& x1, const T2& x2) { + return x1 == x2 ? AssertionSuccess() : + AssertionFailure(Message() << "Failure"); } // Tests that overloaded functions can be used in *_PRED_FORMAT* @@ -1451,8 +1440,6 @@ TEST(StringAssertionTest, STRNE_Wide) { // Tests that IsSubstring() returns the correct result when the input // argument type is const char*. TEST(IsSubstringTest, ReturnsCorrectResultForCString) { - using ::testing::IsSubstring; - EXPECT_FALSE(IsSubstring("", "", NULL, "a")); EXPECT_FALSE(IsSubstring("", "", "b", NULL)); EXPECT_FALSE(IsSubstring("", "", "needle", "haystack")); @@ -1464,8 +1451,6 @@ TEST(IsSubstringTest, ReturnsCorrectResultForCString) { // Tests that IsSubstring() returns the correct result when the input // argument type is const wchar_t*. TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) { - using ::testing::IsSubstring; - EXPECT_FALSE(IsSubstring("", "", NULL, L"a")); EXPECT_FALSE(IsSubstring("", "", L"b", NULL)); EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack")); @@ -1481,8 +1466,8 @@ TEST(IsSubstringTest, GeneratesCorrectMessageForCString) { " Actual: \"needle\"\n" "Expected: a substring of haystack_expr\n" "Which is: \"haystack\"", - ::testing::IsSubstring("needle_expr", "haystack_expr", - "needle", "haystack").failure_message()); + IsSubstring("needle_expr", "haystack_expr", + "needle", "haystack").failure_message()); } #if GTEST_HAS_STD_STRING @@ -1490,8 +1475,8 @@ TEST(IsSubstringTest, GeneratesCorrectMessageForCString) { // Tests that IsSubstring returns the correct result when the input // argument type is ::std::string. TEST(IsSubstringTest, ReturnsCorrectResultsForStdString) { - EXPECT_TRUE(::testing::IsSubstring("", "", std::string("hello"), "ahellob")); - EXPECT_FALSE(::testing::IsSubstring("", "", "hello", std::string("world"))); + EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob")); + EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world"))); } #endif // GTEST_HAS_STD_STRING @@ -1500,8 +1485,6 @@ TEST(IsSubstringTest, ReturnsCorrectResultsForStdString) { // Tests that IsSubstring returns the correct result when the input // argument type is ::std::wstring. TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) { - using ::testing::IsSubstring; - EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles")); EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack"))); } @@ -1513,7 +1496,7 @@ TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) { " Actual: L\"needle\"\n" "Expected: a substring of haystack_expr\n" "Which is: L\"haystack\"", - ::testing::IsSubstring( + IsSubstring( "needle_expr", "haystack_expr", ::std::wstring(L"needle"), L"haystack").failure_message()); } @@ -1525,8 +1508,6 @@ TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) { // Tests that IsNotSubstring() returns the correct result when the input // argument type is const char*. TEST(IsNotSubstringTest, ReturnsCorrectResultForCString) { - using ::testing::IsNotSubstring; - EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack")); EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles")); } @@ -1534,8 +1515,6 @@ TEST(IsNotSubstringTest, ReturnsCorrectResultForCString) { // Tests that IsNotSubstring() returns the correct result when the input // argument type is const wchar_t*. TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) { - using ::testing::IsNotSubstring; - EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack")); EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles")); } @@ -1547,7 +1526,7 @@ TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) { " Actual: L\"needle\"\n" "Expected: not a substring of haystack_expr\n" "Which is: L\"two needles\"", - ::testing::IsNotSubstring( + IsNotSubstring( "needle_expr", "haystack_expr", L"needle", L"two needles").failure_message()); } @@ -1557,8 +1536,6 @@ TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) { // Tests that IsNotSubstring returns the correct result when the input // argument type is ::std::string. TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) { - using ::testing::IsNotSubstring; - EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob")); EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world"))); } @@ -1570,7 +1547,7 @@ TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) { " Actual: \"needle\"\n" "Expected: not a substring of haystack_expr\n" "Which is: \"two needles\"", - ::testing::IsNotSubstring( + IsNotSubstring( "needle_expr", "haystack_expr", ::std::string("needle"), "two needles").failure_message()); } @@ -1582,8 +1559,6 @@ TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) { // Tests that IsNotSubstring returns the correct result when the input // argument type is ::std::wstring. TEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) { - using ::testing::IsNotSubstring; - EXPECT_FALSE( IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles")); EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack"))); @@ -1594,7 +1569,7 @@ TEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) { // Tests floating-point assertions. template -class FloatingPointTest : public testing::Test { +class FloatingPointTest : public Test { protected: typedef typename testing::internal::FloatingPoint Floating; typedef typename Floating::Bits Bits; @@ -1801,34 +1776,34 @@ TEST_F(FloatTest, ASSERT_NEAR) { // Tests the cases where FloatLE() should succeed. TEST_F(FloatTest, FloatLESucceeds) { - EXPECT_PRED_FORMAT2(testing::FloatLE, 1.0f, 2.0f); // When val1 < val2, - ASSERT_PRED_FORMAT2(testing::FloatLE, 1.0f, 1.0f); // val1 == val2, + EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f); // When val1 < val2, + ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f); // val1 == val2, // or when val1 is greater than, but almost equals to, val2. - EXPECT_PRED_FORMAT2(testing::FloatLE, close_to_positive_zero_, 0.0f); + EXPECT_PRED_FORMAT2(FloatLE, close_to_positive_zero_, 0.0f); } // Tests the cases where FloatLE() should fail. TEST_F(FloatTest, FloatLEFails) { // When val1 is greater than val2 by a large margin, - EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(testing::FloatLE, 2.0f, 1.0f), + EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f), "(2.0f) <= (1.0f)"); // or by a small yet non-negligible margin, EXPECT_NONFATAL_FAILURE({ // NOLINT - EXPECT_PRED_FORMAT2(testing::FloatLE, further_from_one_, 1.0f); + EXPECT_PRED_FORMAT2(FloatLE, further_from_one_, 1.0f); }, "(further_from_one_) <= (1.0f)"); // or when either val1 or val2 is NaN. EXPECT_NONFATAL_FAILURE({ // NOLINT - EXPECT_PRED_FORMAT2(testing::FloatLE, nan1_, infinity_); + EXPECT_PRED_FORMAT2(FloatLE, nan1_, infinity_); }, "(nan1_) <= (infinity_)"); EXPECT_NONFATAL_FAILURE({ // NOLINT - EXPECT_PRED_FORMAT2(testing::FloatLE, -infinity_, nan1_); + EXPECT_PRED_FORMAT2(FloatLE, -infinity_, nan1_); }, "(-infinity_) <= (nan1_)"); EXPECT_FATAL_FAILURE({ // NOLINT - ASSERT_PRED_FORMAT2(testing::FloatLE, nan1_, nan1_); + ASSERT_PRED_FORMAT2(FloatLE, nan1_, nan1_); }, "(nan1_) <= (nan1_)"); } @@ -1958,33 +1933,33 @@ TEST_F(DoubleTest, ASSERT_NEAR) { // Tests the cases where DoubleLE() should succeed. TEST_F(DoubleTest, DoubleLESucceeds) { - EXPECT_PRED_FORMAT2(testing::DoubleLE, 1.0, 2.0); // When val1 < val2, - ASSERT_PRED_FORMAT2(testing::DoubleLE, 1.0, 1.0); // val1 == val2, + EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0); // When val1 < val2, + ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0); // val1 == val2, // or when val1 is greater than, but almost equals to, val2. - EXPECT_PRED_FORMAT2(testing::DoubleLE, close_to_positive_zero_, 0.0); + EXPECT_PRED_FORMAT2(DoubleLE, close_to_positive_zero_, 0.0); } // Tests the cases where DoubleLE() should fail. TEST_F(DoubleTest, DoubleLEFails) { // When val1 is greater than val2 by a large margin, - EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(testing::DoubleLE, 2.0, 1.0), + EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0), "(2.0) <= (1.0)"); // or by a small yet non-negligible margin, EXPECT_NONFATAL_FAILURE({ // NOLINT - EXPECT_PRED_FORMAT2(testing::DoubleLE, further_from_one_, 1.0); + EXPECT_PRED_FORMAT2(DoubleLE, further_from_one_, 1.0); }, "(further_from_one_) <= (1.0)"); // or when either val1 or val2 is NaN. EXPECT_NONFATAL_FAILURE({ // NOLINT - EXPECT_PRED_FORMAT2(testing::DoubleLE, nan1_, infinity_); + EXPECT_PRED_FORMAT2(DoubleLE, nan1_, infinity_); }, "(nan1_) <= (infinity_)"); EXPECT_NONFATAL_FAILURE({ // NOLINT - EXPECT_PRED_FORMAT2(testing::DoubleLE, -infinity_, nan1_); + EXPECT_PRED_FORMAT2(DoubleLE, -infinity_, nan1_); }, " (-infinity_) <= (nan1_)"); EXPECT_FATAL_FAILURE({ // NOLINT - ASSERT_PRED_FORMAT2(testing::DoubleLE, nan1_, nan1_); + ASSERT_PRED_FORMAT2(DoubleLE, nan1_, nan1_); }, "(nan1_) <= (nan1_)"); } @@ -2018,7 +1993,7 @@ TEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) { // Check that when all tests in a test case are disabled, SetupTestCase() and // TearDownTestCase() are not called. -class DisabledTestsTest : public testing::Test { +class DisabledTestsTest : public Test { protected: static void SetUpTestCase() { FAIL() << "Unexpected failure: All tests disabled in test case. " @@ -2042,7 +2017,7 @@ TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) { // Tests that assertion macros evaluate their arguments exactly once. -class SingleEvaluationTest : public testing::Test { +class SingleEvaluationTest : public Test { protected: SingleEvaluationTest() { p1_ = s1_; @@ -2196,7 +2171,7 @@ TEST(AssertionTest, EqFailure) { TEST(AssertionTest, AppendUserMessage) { const String foo("foo"); - testing::Message msg; + Message msg; EXPECT_STREQ("foo", AppendUserMessage(foo, msg).c_str()); @@ -2410,7 +2385,7 @@ enum { // On Linux, CASE_B and CASE_A have the same value when truncated to // int size. We want to test whether this will confuse the // assertions. - CASE_B = ::testing::internal::kMaxBiggestInt, + CASE_B = testing::internal::kMaxBiggestInt, #else CASE_B = INT_MAX, #endif // GTEST_OS_LINUX @@ -3194,7 +3169,7 @@ TEST(FRIEND_TEST_Test, TEST) { } // The fixture needed to test using FRIEND_TEST with TEST_F. -class FRIEND_TEST_Test2 : public testing::Test { +class FRIEND_TEST_Test2 : public Test { protected: Foo foo; }; @@ -3211,7 +3186,7 @@ TEST_F(FRIEND_TEST_Test2, TEST_F) { // // This class counts the number of live test objects that uses this // fixture. -class TestLifeCycleTest : public testing::Test { +class TestLifeCycleTest : public Test { protected: // Constructor. Increments the number of test objects that uses // this fixture. @@ -3266,7 +3241,7 @@ std::ostream& operator<<(std::ostream& os, } TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) { - testing::Message msg; + Message msg; Base a(1); msg << a << &a; // Uses ::operator<<. @@ -3291,7 +3266,7 @@ std::ostream& operator<<(std::ostream& os, } // namespace TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) { - testing::Message msg; + Message msg; MyTypeInUnnamedNameSpace a(1); msg << a << &a; // Uses ::operator<<. @@ -3316,7 +3291,7 @@ std::ostream& operator<<(std::ostream& os, } // namespace namespace1 TEST(MessageTest, CanStreamUserTypeInUserNameSpace) { - testing::Message msg; + Message msg; namespace1::MyTypeInNameSpace1 a(1); msg << a << &a; // Uses namespace1::operator<<. @@ -3341,7 +3316,7 @@ std::ostream& operator<<(std::ostream& os, } TEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) { - testing::Message msg; + Message msg; namespace2::MyTypeInNameSpace2 a(1); msg << a << &a; // Uses ::operator<<. @@ -3350,13 +3325,13 @@ TEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) { // Tests streaming NULL pointers to testing::Message. TEST(MessageTest, NullPointers) { - testing::Message msg; + Message msg; char* const p1 = NULL; unsigned char* const p2 = NULL; int* p3 = NULL; double* p4 = NULL; bool* p5 = NULL; - testing::Message* p6 = NULL; + Message* p6 = NULL; msg << p1 << p2 << p3 << p4 << p5 << p6; ASSERT_STREQ("(null)(null)(null)(null)(null)(null)", @@ -3365,8 +3340,6 @@ TEST(MessageTest, NullPointers) { // Tests streaming wide strings to testing::Message. TEST(MessageTest, WideStrings) { - using testing::Message; - // Streams a NULL of type const wchar_t*. const wchar_t* const_wstr = NULL; EXPECT_STREQ("(null)", @@ -3394,7 +3367,7 @@ namespace testing { // Tests the TestInfo class. -class TestInfoTest : public testing::Test { +class TestInfoTest : public Test { protected: static TestInfo * GetTestInfo(const char* test_name) { return UnitTest::GetInstance()->impl()-> @@ -3403,7 +3376,7 @@ class TestInfoTest : public testing::Test { } static const TestResult* GetTestResult( - const testing::TestInfo* test_info) { + const TestInfo* test_info) { return test_info->result(); } }; @@ -3429,7 +3402,7 @@ TEST_F(TestInfoTest, result) { // Tests setting up and tearing down a test case. -class SetUpTestCaseTest : public testing::Test { +class SetUpTestCaseTest : public Test { protected: // This will be called once before the first test in this test case // is run. @@ -3572,7 +3545,7 @@ struct Flags { }; // Fixture for testing InitGoogleTest(). -class InitGoogleTestTest : public testing::Test { +class InitGoogleTestTest : public Test { protected: // Clears the flags before each test. virtual void SetUp() { @@ -4203,13 +4176,13 @@ TEST(NestedTestingNamespaceTest, Failure) { // that is, that they are not private. // No tests are based on this fixture; the test "passes" if it compiles // successfully. -class ProtectedFixtureMethodsTest : public testing::Test { +class ProtectedFixtureMethodsTest : public Test { protected: virtual void SetUp() { - testing::Test::SetUp(); + Test::SetUp(); } virtual void TearDown() { - testing::Test::TearDown(); + Test::TearDown(); } }; -- cgit v1.2.3