Index: ext/googletest/googletest/test/gtest_unittest.cc
===================================================================
diff -u -N -r4a481bbe77043e0bda2435c6d62a02700b3e46c5 -r2e4eacb299f21d06196fe13140b4b0d095abdca9
--- ext/googletest/googletest/test/gtest_unittest.cc (.../gtest_unittest.cc) (revision 4a481bbe77043e0bda2435c6d62a02700b3e46c5)
+++ ext/googletest/googletest/test/gtest_unittest.cc (.../gtest_unittest.cc) (revision 2e4eacb299f21d06196fe13140b4b0d095abdca9)
@@ -26,17 +26,16 @@
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
//
-// Author: wan@google.com (Zhanyong Wan)
-//
// Tests for Google Test itself. This verifies that the basic constructs of
// Google Test work.
#include "gtest/gtest.h"
-// Verifies that the command line flag variables can be accessed
-// in code once <gtest/gtest.h> has been #included.
-// Do not move it after other #includes.
+// Verifies that the command line flag variables can be accessed in
+// code once "gtest.h" has been #included.
+// Do not move it after other gtest #includes.
TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
bool dummy = testing::GTEST_FLAG(also_run_disabled_tests)
|| testing::GTEST_FLAG(break_on_failure)
@@ -64,17 +63,12 @@
#include <map>
#include <vector>
#include <ostream>
+#if GTEST_LANG_CXX11
+#include <unordered_set>
+#endif // GTEST_LANG_CXX11
#include "gtest/gtest-spi.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_
namespace testing {
namespace internal {
@@ -86,9 +80,9 @@
class FakeSocketWriter : public StreamingListener::AbstractSocketWriter {
public:
// Sends a string to the socket.
- virtual void Send(const string& message) { output_ += message; }
+ virtual void Send(const std::string& message) { output_ += message; }
- string output_;
+ std::string output_;
};
StreamingListenerTest()
@@ -98,7 +92,7 @@
CodeLocation(__FILE__, __LINE__), 0, NULL) {}
protected:
- string* output() { return &(fake_sock_writer_->output_); }
+ std::string* output() { return &(fake_sock_writer_->output_); }
FakeSocketWriter* const fake_sock_writer_;
StreamingListener streamer_;
@@ -266,6 +260,8 @@
using testing::internal::IsContainerTest;
using testing::internal::IsNotContainer;
using testing::internal::NativeArray;
+using testing::internal::OsStackTraceGetter;
+using testing::internal::OsStackTraceGetterInterface;
using testing::internal::ParseInt32Flag;
using testing::internal::RelationToSourceCopy;
using testing::internal::RelationToSourceReference;
@@ -282,6 +278,7 @@
using testing::internal::TestEventListenersAccessor;
using testing::internal::TestResultAccessor;
using testing::internal::UInt32;
+using testing::internal::UnitTestImpl;
using testing::internal::WideStringToUtf8;
using testing::internal::edit_distance::CalculateOptimalEdits;
using testing::internal::edit_distance::CreateUnifiedDiff;
@@ -382,6 +379,31 @@
EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId());
}
+// Tests CanonicalizeForStdLibVersioning.
+
+using ::testing::internal::CanonicalizeForStdLibVersioning;
+
+TEST(CanonicalizeForStdLibVersioning, LeavesUnversionedNamesUnchanged) {
+ EXPECT_EQ("std::bind", CanonicalizeForStdLibVersioning("std::bind"));
+ EXPECT_EQ("std::_", CanonicalizeForStdLibVersioning("std::_"));
+ EXPECT_EQ("std::__foo", CanonicalizeForStdLibVersioning("std::__foo"));
+ EXPECT_EQ("gtl::__1::x", CanonicalizeForStdLibVersioning("gtl::__1::x"));
+ EXPECT_EQ("__1::x", CanonicalizeForStdLibVersioning("__1::x"));
+ EXPECT_EQ("::__1::x", CanonicalizeForStdLibVersioning("::__1::x"));
+}
+
+TEST(CanonicalizeForStdLibVersioning, ElidesDoubleUnderNames) {
+ EXPECT_EQ("std::bind", CanonicalizeForStdLibVersioning("std::__1::bind"));
+ EXPECT_EQ("std::_", CanonicalizeForStdLibVersioning("std::__1::_"));
+
+ EXPECT_EQ("std::bind", CanonicalizeForStdLibVersioning("std::__g::bind"));
+ EXPECT_EQ("std::_", CanonicalizeForStdLibVersioning("std::__g::_"));
+
+ EXPECT_EQ("std::bind",
+ CanonicalizeForStdLibVersioning("std::__google::bind"));
+ EXPECT_EQ("std::_", CanonicalizeForStdLibVersioning("std::__google::_"));
+}
+
// Tests FormatTimeInMillisAsSeconds().
TEST(FormatTimeInMillisAsSecondsTest, FormatsZero) {
@@ -421,10 +443,10 @@
virtual void SetUp() {
saved_tz_ = NULL;
- GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* getenv, strdup: deprecated */)
+ GTEST_DISABLE_MSC_DEPRECATED_PUSH_(/* getenv, strdup: deprecated */)
if (getenv("TZ"))
saved_tz_ = strdup(getenv("TZ"));
- GTEST_DISABLE_MSC_WARNINGS_POP_()
+ GTEST_DISABLE_MSC_DEPRECATED_POP_()
// Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use. We
// cannot use the local time zone because the function's output depends
@@ -442,7 +464,7 @@
// tzset() distinguishes between the TZ variable being present and empty
// and not being present, so we have to consider the case of time_zone
// being NULL.
-#if _MSC_VER
+#if _MSC_VER || GTEST_OS_WINDOWS_MINGW
// ...Unless it's MSVC, whose standard library's _putenv doesn't
// distinguish between an empty and a missing variable.
const std::string env_var =
@@ -546,7 +568,7 @@
// 101 0111 0110 => 110-10101 10-110110
// Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints
- // in wide strings and wide chars. In order to accomodate them, we have to
+ // in wide strings and wide chars. In order to accommodate them, we have to
// introduce such character constants as integers.
EXPECT_EQ("\xD5\xB6",
CodePointToUtf8(static_cast<wchar_t>(0x576)));
@@ -1362,8 +1384,7 @@
// In order to test TestResult, we need to modify its internal
// state, in particular the TestPartResult vector it holds.
// test_part_results() returns a const reference to this vector.
- // We cast it to a non-const object s.t. it can be modified (yes,
- // this is a hack).
+ // We cast it to a non-const object s.t. it can be modified
TPRVector* results1 = const_cast<TPRVector*>(
&TestResultAccessor::test_part_results(*r1));
TPRVector* results2 = const_cast<TPRVector*>(
@@ -1388,7 +1409,7 @@
delete r2;
}
- // Helper that compares two two TestPartResults.
+ // Helper that compares two TestPartResults.
static void CompareTestPartResult(const TestPartResult& expected,
const TestPartResult& actual) {
EXPECT_EQ(expected.type(), actual.type());
@@ -1787,7 +1808,7 @@
}
// Tests that Int32FromEnvOrDie() aborts with an error message
-// if the variable cannot be represnted by an Int32.
+// if the variable cannot be represented by an Int32.
TEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) {
SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234");
EXPECT_DEATH_IF_SUPPORTED(
@@ -2069,8 +2090,8 @@
AddRecordWithReservedKeysGeneratesCorrectPropertyList) {
EXPECT_NONFATAL_FAILURE(
Test::RecordProperty("name", "1"),
- "'classname', 'name', 'status', 'time', 'type_param', and 'value_param'"
- " are reserved");
+ "'classname', 'name', 'status', 'time', 'type_param', 'value_param',"
+ " 'file', and 'line' are reserved");
}
class UnitTestRecordPropertyTestEnvironment : public Environment {
@@ -2430,7 +2451,7 @@
ASSERT_STREQ(p1, p2);
EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
- "Expected: \"bad\"");
+ " \"bad\"\n \"good\"");
}
// Tests ASSERT_STREQ with NULL arguments.
@@ -3115,13 +3136,13 @@
FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
}
-// Check that when all tests in a test case are disabled, SetupTestCase() and
+// Check that when all tests in a test case are disabled, SetUpTestCase() and
// TearDownTestCase() are not called.
class DisabledTestsTest : public Test {
protected:
static void SetUpTestCase() {
FAIL() << "Unexpected failure: All tests disabled in test case. "
- "SetupTestCase() should not be called.";
+ "SetUpTestCase() should not be called.";
}
static void TearDownTestCase() {
@@ -3368,7 +3389,7 @@
void DoAssertNoFatalFailureOnFails() {
ASSERT_NO_FATAL_FAILURE(Fails());
- ADD_FAILURE() << "shold not reach here.";
+ ADD_FAILURE() << "should not reach here.";
}
void DoExpectNoFatalFailureOnFails() {
@@ -3528,46 +3549,51 @@
EqFailure("foo", "bar", foo_val, bar_val, false)
.failure_message());
EXPECT_STREQ(
- " Expected: foo\n"
- " Which is: 5\n"
- "To be equal to: bar\n"
- " Which is: 6",
+ "Expected equality of these values:\n"
+ " foo\n"
+ " Which is: 5\n"
+ " bar\n"
+ " Which is: 6",
msg1.c_str());
const std::string msg2(
EqFailure("foo", "6", foo_val, bar_val, false)
.failure_message());
EXPECT_STREQ(
- " Expected: foo\n"
- " Which is: 5\n"
- "To be equal to: 6",
+ "Expected equality of these values:\n"
+ " foo\n"
+ " Which is: 5\n"
+ " 6",
msg2.c_str());
const std::string msg3(
EqFailure("5", "bar", foo_val, bar_val, false)
.failure_message());
EXPECT_STREQ(
- " Expected: 5\n"
- "To be equal to: bar\n"
- " Which is: 6",
+ "Expected equality of these values:\n"
+ " 5\n"
+ " bar\n"
+ " Which is: 6",
msg3.c_str());
const std::string msg4(
EqFailure("5", "6", foo_val, bar_val, false).failure_message());
EXPECT_STREQ(
- " Expected: 5\n"
- "To be equal to: 6",
+ "Expected equality of these values:\n"
+ " 5\n"
+ " 6",
msg4.c_str());
const std::string msg5(
EqFailure("foo", "bar",
std::string("\"x\""), std::string("\"y\""),
true).failure_message());
EXPECT_STREQ(
- " Expected: foo\n"
- " Which is: \"x\"\n"
- "To be equal to: bar\n"
- " Which is: \"y\"\n"
+ "Expected equality of these values:\n"
+ " foo\n"
+ " Which is: \"x\"\n"
+ " bar\n"
+ " Which is: \"y\"\n"
"Ignoring case",
msg5.c_str());
}
@@ -3580,11 +3606,12 @@
const std::string msg1(
EqFailure("left", "right", left, right, false).failure_message());
EXPECT_STREQ(
- " Expected: left\n"
- " Which is: "
+ "Expected equality of these values:\n"
+ " left\n"
+ " Which is: "
"1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15\n"
- "To be equal to: right\n"
- " Which is: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n"
+ " right\n"
+ " Which is: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n"
"With diff:\n@@ -1,5 +1,6 @@\n 1\n-2XXX\n+2\n 3\n+4\n 5\n 6\n"
"@@ -7,8 +8,6 @@\n 8\n 9\n-10\n 11\n-12XXX\n+12\n 13\n 14\n-15\n",
msg1.c_str());
@@ -3659,7 +3686,7 @@
}
#ifdef __BORLANDC__
-// Restores warnings after previous "#pragma option push" supressed them
+// Restores warnings after previous "#pragma option push" suppressed them
# pragma option pop
#endif
@@ -3679,17 +3706,18 @@
TEST(AssertionTest, ASSERT_EQ) {
ASSERT_EQ(5, 2 + 3);
EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
- " Expected: 5\n"
- "To be equal to: 2*3\n"
- " Which is: 6");
+ "Expected equality of these values:\n"
+ " 5\n"
+ " 2*3\n"
+ " Which is: 6");
}
// Tests ASSERT_EQ(NULL, pointer).
#if GTEST_CAN_COMPARE_NULL
TEST(AssertionTest, ASSERT_EQ_NULL) {
// A success.
const char* p = NULL;
- // Some older GCC versions may issue a spurious waring in this or the next
+ // Some older GCC versions may issue a spurious warning in this or the next
// assertion statement. This warning should not be suppressed with
// static_cast since the test verifies the ability to use bare NULL as the
// expected parameter to the macro.
@@ -3698,7 +3726,7 @@
// A failure.
static int n = 0;
EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),
- "To be equal to: &n\n");
+ " &n\n Which is:");
}
#endif // GTEST_CAN_COMPARE_NULL
@@ -3714,7 +3742,7 @@
// A failure.
EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
- "Expected: 0");
+ " 0\n 5.6");
}
// Tests ASSERT_NE.
@@ -3813,7 +3841,7 @@
// Tests calling a test subroutine that's not part of a fixture.
TEST(AssertionTest, NonFixtureSubroutine) {
EXPECT_FATAL_FAILURE(TestEq1(2),
- "To be equal to: x");
+ " x\n Which is: 2");
}
// An uncopyable class.
@@ -3862,7 +3890,8 @@
EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
"IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
- "Expected: x\n Which is: 5\nTo be equal to: y\n Which is: -1");
+ "Expected equality of these values:\n"
+ " x\n Which is: 5\n y\n Which is: -1");
}
// Tests that uncopyable objects can be used in expects.
@@ -3874,7 +3903,8 @@
"IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
EXPECT_EQ(x, x);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
- "Expected: x\n Which is: 5\nTo be equal to: y\n Which is: -1");
+ "Expected equality of these values:\n"
+ " x\n Which is: 5\n y\n Which is: -1");
}
enum NamedEnum {
@@ -3950,13 +3980,13 @@
// ICE's in C++Builder.
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
- "To be equal to: kCaseB");
+ " kCaseB\n Which is: ");
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
- "Which is: 42");
+ "\n Which is: 42");
# endif
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
- "Which is: -1");
+ "\n Which is: -1");
}
#endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
@@ -4382,17 +4412,18 @@
}
#ifdef __BORLANDC__
-// Restores warnings after previous "#pragma option push" supressed them
+// Restores warnings after previous "#pragma option push" suppressed them
# pragma option pop
#endif
// Tests EXPECT_EQ.
TEST(ExpectTest, EXPECT_EQ) {
EXPECT_EQ(5, 2 + 3);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
- " Expected: 5\n"
- "To be equal to: 2*3\n"
- " Which is: 6");
+ "Expected equality of these values:\n"
+ " 5\n"
+ " 2*3\n"
+ " Which is: 6");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
"2 - 3");
}
@@ -4423,7 +4454,7 @@
// A failure.
int n = 0;
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
- "To be equal to: &n\n");
+ " &n\n Which is:");
}
#endif // GTEST_CAN_COMPARE_NULL
@@ -4439,7 +4470,7 @@
// A failure.
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
- "Expected: 0");
+ " 0\n 5.6");
}
// Tests EXPECT_NE.
@@ -4539,7 +4570,7 @@
TEST(ExpectTest, ExpectPrecedence) {
EXPECT_EQ(1 < 2, true);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),
- "To be equal to: true && false");
+ " true && false\n Which is: false");
}
@@ -4656,7 +4687,7 @@
// Unfortunately, we cannot verify that the failure message contains
// the right file path and line number the same way, as
// EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and
- // line number. Instead, we do that in gtest_output_test_.cc.
+ // line number. Instead, we do that in googletest-output-test_.cc.
}
// Tests FAIL.
@@ -4686,14 +4717,14 @@
EXPECT_FATAL_FAILURE({
bool false_value = false;
ASSERT_EQ(false_value, true);
- }, "To be equal to: true");
+ }, " false_value\n Which is: false\n true");
}
// Tests using int values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest, Int) {
ASSERT_EQ(32, 32);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),
- "33");
+ " 32\n 33");
}
// Tests using time_t values in {EXPECT|ASSERT}_EQ.
@@ -4710,28 +4741,29 @@
ASSERT_EQ('z', 'z');
const char ch = 'b';
EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),
- "ch");
+ " ch\n Which is: 'b'");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),
- "ch");
+ " ch\n Which is: 'b'");
}
// Tests using wchar_t values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest, WideChar) {
EXPECT_EQ(L'b', L'b');
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'),
- " Expected: L'\0'\n"
- " Which is: L'\0' (0, 0x0)\n"
- "To be equal to: L'x'\n"
- " Which is: L'x' (120, 0x78)");
+ "Expected equality of these values:\n"
+ " L'\0'\n"
+ " Which is: L'\0' (0, 0x0)\n"
+ " L'x'\n"
+ " Which is: L'x' (120, 0x78)");
static wchar_t wchar;
wchar = L'b';
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar),
"wchar");
wchar = 0x8119;
EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
- "To be equal to: wchar");
+ " wchar\n Which is: L'");
}
// Tests using ::std::string values in {EXPECT|ASSERT}_EQ.
@@ -4760,8 +4792,7 @@
static ::std::string str3(str1);
str3.at(2) = '\0';
EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),
- "To be equal to: str3\n"
- " Which is: \"A \\0 in the middle\"");
+ " str3\n Which is: \"A \\0 in the middle\"");
}
#if GTEST_HAS_STD_WSTRING
@@ -4881,9 +4912,9 @@
ASSERT_EQ(p1, p1);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
- "To be equal to: p2");
+ " p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
- "p2");
+ " p2\n Which is:");
EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
reinterpret_cast<char*>(0xABC0)),
"ABC0");
@@ -4903,9 +4934,9 @@
EXPECT_EQ(p0, p0);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
- "To be equal to: p2");
+ " p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
- "p2");
+ " p2\n Which is:");
void* pv3 = (void*)0x1234; // NOLINT
void* pv4 = (void*)0xABC0; // NOLINT
const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);
@@ -5450,8 +5481,9 @@
EXPECT_STREQ("123", shared_resource_);
}
-// The InitGoogleTestTest test case tests testing::InitGoogleTest().
+// The ParseFlagsTest test case tests ParseGoogleTestFlagsOnly.
+
// The Flags struct stores a copy of all Google Test flags.
struct Flags {
// Constructs a Flags struct where each flag has its default value.
@@ -5536,8 +5568,8 @@
return flags;
}
- // Creates a Flags struct where the gtest_random_seed flag has
- // the given value.
+ // Creates a Flags struct where the gtest_random_seed flag has the given
+ // value.
static Flags RandomSeed(Int32 random_seed) {
Flags flags;
flags.random_seed = random_seed;
@@ -5552,8 +5584,8 @@
return flags;
}
- // Creates a Flags struct where the gtest_shuffle flag has
- // the given value.
+ // Creates a Flags struct where the gtest_shuffle flag has the given
+ // value.
static Flags Shuffle(bool shuffle) {
Flags flags;
flags.shuffle = shuffle;
@@ -5601,8 +5633,8 @@
bool throw_on_failure;
};
-// Fixture for testing InitGoogleTest().
-class InitGoogleTestTest : public Test {
+// Fixture for testing ParseGoogleTestFlagsOnly().
+class ParseFlagsTest : public Test {
protected:
// Clears the flags before each test.
virtual void SetUp() {
@@ -5663,16 +5695,16 @@
const bool saved_help_flag = ::testing::internal::g_help_flag;
::testing::internal::g_help_flag = false;
-#if GTEST_HAS_STREAM_REDIRECTION
+# if GTEST_HAS_STREAM_REDIRECTION
CaptureStdout();
-#endif
+# endif
// Parses the command line.
internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
-#if GTEST_HAS_STREAM_REDIRECTION
+# if GTEST_HAS_STREAM_REDIRECTION
const std::string captured_stdout = GetCapturedStdout();
-#endif
+# endif
// Verifies the flag values.
CheckFlags(expected);
@@ -5685,7 +5717,7 @@
// help message for the flags it recognizes.
EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);
-#if GTEST_HAS_STREAM_REDIRECTION
+# if GTEST_HAS_STREAM_REDIRECTION
const char* const expected_help_fragment =
"This program contains tests written using";
if (should_print_help) {
@@ -5694,22 +5726,22 @@
EXPECT_PRED_FORMAT2(IsNotSubstring,
expected_help_fragment, captured_stdout);
}
-#endif // GTEST_HAS_STREAM_REDIRECTION
+# endif // GTEST_HAS_STREAM_REDIRECTION
::testing::internal::g_help_flag = saved_help_flag;
}
// This macro wraps TestParsingFlags s.t. the user doesn't need
// to specify the array sizes.
-#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
+# define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
expected, should_print_help)
};
// Tests parsing an empty command line.
-TEST_F(InitGoogleTestTest, Empty) {
+TEST_F(ParseFlagsTest, Empty) {
const char* argv[] = {
NULL
};
@@ -5722,7 +5754,7 @@
}
// Tests parsing a command line that has no flag.
-TEST_F(InitGoogleTestTest, NoFlag) {
+TEST_F(ParseFlagsTest, NoFlag) {
const char* argv[] = {
"foo.exe",
NULL
@@ -5737,7 +5769,7 @@
}
// Tests parsing a bad --gtest_filter flag.
-TEST_F(InitGoogleTestTest, FilterBad) {
+TEST_F(ParseFlagsTest, FilterBad) {
const char* argv[] = {
"foo.exe",
"--gtest_filter",
@@ -5754,7 +5786,7 @@
}
// Tests parsing an empty --gtest_filter flag.
-TEST_F(InitGoogleTestTest, FilterEmpty) {
+TEST_F(ParseFlagsTest, FilterEmpty) {
const char* argv[] = {
"foo.exe",
"--gtest_filter=",
@@ -5770,7 +5802,7 @@
}
// Tests parsing a non-empty --gtest_filter flag.
-TEST_F(InitGoogleTestTest, FilterNonEmpty) {
+TEST_F(ParseFlagsTest, FilterNonEmpty) {
const char* argv[] = {
"foo.exe",
"--gtest_filter=abc",
@@ -5786,7 +5818,7 @@
}
// Tests parsing --gtest_break_on_failure.
-TEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) {
+TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure",
@@ -5802,7 +5834,7 @@
}
// Tests parsing --gtest_break_on_failure=0.
-TEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) {
+TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure=0",
@@ -5818,7 +5850,7 @@
}
// Tests parsing --gtest_break_on_failure=f.
-TEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) {
+TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure=f",
@@ -5834,7 +5866,7 @@
}
// Tests parsing --gtest_break_on_failure=F.
-TEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) {
+TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure=F",
@@ -5851,7 +5883,7 @@
// Tests parsing a --gtest_break_on_failure flag that has a "true"
// definition.
-TEST_F(InitGoogleTestTest, BreakOnFailureTrue) {
+TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure=1",
@@ -5867,7 +5899,7 @@
}
// Tests parsing --gtest_catch_exceptions.
-TEST_F(InitGoogleTestTest, CatchExceptions) {
+TEST_F(ParseFlagsTest, CatchExceptions) {
const char* argv[] = {
"foo.exe",
"--gtest_catch_exceptions",
@@ -5883,7 +5915,7 @@
}
// Tests parsing --gtest_death_test_use_fork.
-TEST_F(InitGoogleTestTest, DeathTestUseFork) {
+TEST_F(ParseFlagsTest, DeathTestUseFork) {
const char* argv[] = {
"foo.exe",
"--gtest_death_test_use_fork",
@@ -5900,7 +5932,7 @@
// Tests having the same flag twice with different values. The
// expected behavior is that the one coming last takes precedence.
-TEST_F(InitGoogleTestTest, DuplicatedFlags) {
+TEST_F(ParseFlagsTest, DuplicatedFlags) {
const char* argv[] = {
"foo.exe",
"--gtest_filter=a",
@@ -5917,7 +5949,7 @@
}
// Tests having an unrecognized flag on the command line.
-TEST_F(InitGoogleTestTest, UnrecognizedFlag) {
+TEST_F(ParseFlagsTest, UnrecognizedFlag) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure",
@@ -5939,7 +5971,7 @@
}
// Tests having a --gtest_list_tests flag
-TEST_F(InitGoogleTestTest, ListTestsFlag) {
+TEST_F(ParseFlagsTest, ListTestsFlag) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests",
@@ -5955,7 +5987,7 @@
}
// Tests having a --gtest_list_tests flag with a "true" value
-TEST_F(InitGoogleTestTest, ListTestsTrue) {
+TEST_F(ParseFlagsTest, ListTestsTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests=1",
@@ -5971,7 +6003,7 @@
}
// Tests having a --gtest_list_tests flag with a "false" value
-TEST_F(InitGoogleTestTest, ListTestsFalse) {
+TEST_F(ParseFlagsTest, ListTestsFalse) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests=0",
@@ -5987,7 +6019,7 @@
}
// Tests parsing --gtest_list_tests=f.
-TEST_F(InitGoogleTestTest, ListTestsFalse_f) {
+TEST_F(ParseFlagsTest, ListTestsFalse_f) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests=f",
@@ -6003,7 +6035,7 @@
}
// Tests parsing --gtest_list_tests=F.
-TEST_F(InitGoogleTestTest, ListTestsFalse_F) {
+TEST_F(ParseFlagsTest, ListTestsFalse_F) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests=F",
@@ -6019,7 +6051,7 @@
}
// Tests parsing --gtest_output (invalid).
-TEST_F(InitGoogleTestTest, OutputEmpty) {
+TEST_F(ParseFlagsTest, OutputEmpty) {
const char* argv[] = {
"foo.exe",
"--gtest_output",
@@ -6036,7 +6068,7 @@
}
// Tests parsing --gtest_output=xml
-TEST_F(InitGoogleTestTest, OutputXml) {
+TEST_F(ParseFlagsTest, OutputXml) {
const char* argv[] = {
"foo.exe",
"--gtest_output=xml",
@@ -6052,7 +6084,7 @@
}
// Tests parsing --gtest_output=xml:file
-TEST_F(InitGoogleTestTest, OutputXmlFile) {
+TEST_F(ParseFlagsTest, OutputXmlFile) {
const char* argv[] = {
"foo.exe",
"--gtest_output=xml:file",
@@ -6068,7 +6100,7 @@
}
// Tests parsing --gtest_output=xml:directory/path/
-TEST_F(InitGoogleTestTest, OutputXmlDirectory) {
+TEST_F(ParseFlagsTest, OutputXmlDirectory) {
const char* argv[] = {
"foo.exe",
"--gtest_output=xml:directory/path/",
@@ -6085,7 +6117,7 @@
}
// Tests having a --gtest_print_time flag
-TEST_F(InitGoogleTestTest, PrintTimeFlag) {
+TEST_F(ParseFlagsTest, PrintTimeFlag) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time",
@@ -6101,7 +6133,7 @@
}
// Tests having a --gtest_print_time flag with a "true" value
-TEST_F(InitGoogleTestTest, PrintTimeTrue) {
+TEST_F(ParseFlagsTest, PrintTimeTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time=1",
@@ -6117,7 +6149,7 @@
}
// Tests having a --gtest_print_time flag with a "false" value
-TEST_F(InitGoogleTestTest, PrintTimeFalse) {
+TEST_F(ParseFlagsTest, PrintTimeFalse) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time=0",
@@ -6133,7 +6165,7 @@
}
// Tests parsing --gtest_print_time=f.
-TEST_F(InitGoogleTestTest, PrintTimeFalse_f) {
+TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time=f",
@@ -6149,7 +6181,7 @@
}
// Tests parsing --gtest_print_time=F.
-TEST_F(InitGoogleTestTest, PrintTimeFalse_F) {
+TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time=F",
@@ -6165,7 +6197,7 @@
}
// Tests parsing --gtest_random_seed=number
-TEST_F(InitGoogleTestTest, RandomSeed) {
+TEST_F(ParseFlagsTest, RandomSeed) {
const char* argv[] = {
"foo.exe",
"--gtest_random_seed=1000",
@@ -6181,7 +6213,7 @@
}
// Tests parsing --gtest_repeat=number
-TEST_F(InitGoogleTestTest, Repeat) {
+TEST_F(ParseFlagsTest, Repeat) {
const char* argv[] = {
"foo.exe",
"--gtest_repeat=1000",
@@ -6197,7 +6229,7 @@
}
// Tests having a --gtest_also_run_disabled_tests flag
-TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) {
+TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
const char* argv[] = {
"foo.exe",
"--gtest_also_run_disabled_tests",
@@ -6214,7 +6246,7 @@
}
// Tests having a --gtest_also_run_disabled_tests flag with a "true" value
-TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) {
+TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_also_run_disabled_tests=1",
@@ -6231,7 +6263,7 @@
}
// Tests having a --gtest_also_run_disabled_tests flag with a "false" value
-TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) {
+TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
const char* argv[] = {
"foo.exe",
"--gtest_also_run_disabled_tests=0",
@@ -6248,7 +6280,7 @@
}
// Tests parsing --gtest_shuffle.
-TEST_F(InitGoogleTestTest, ShuffleWithoutValue) {
+TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
const char* argv[] = {
"foo.exe",
"--gtest_shuffle",
@@ -6264,7 +6296,7 @@
}
// Tests parsing --gtest_shuffle=0.
-TEST_F(InitGoogleTestTest, ShuffleFalse_0) {
+TEST_F(ParseFlagsTest, ShuffleFalse_0) {
const char* argv[] = {
"foo.exe",
"--gtest_shuffle=0",
@@ -6279,9 +6311,8 @@
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false);
}
-// Tests parsing a --gtest_shuffle flag that has a "true"
-// definition.
-TEST_F(InitGoogleTestTest, ShuffleTrue) {
+// Tests parsing a --gtest_shuffle flag that has a "true" definition.
+TEST_F(ParseFlagsTest, ShuffleTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_shuffle=1",
@@ -6297,7 +6328,7 @@
}
// Tests parsing --gtest_stack_trace_depth=number.
-TEST_F(InitGoogleTestTest, StackTraceDepth) {
+TEST_F(ParseFlagsTest, StackTraceDepth) {
const char* argv[] = {
"foo.exe",
"--gtest_stack_trace_depth=5",
@@ -6312,7 +6343,7 @@
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);
}
-TEST_F(InitGoogleTestTest, StreamResultTo) {
+TEST_F(ParseFlagsTest, StreamResultTo) {
const char* argv[] = {
"foo.exe",
"--gtest_stream_result_to=localhost:1234",
@@ -6329,7 +6360,7 @@
}
// Tests parsing --gtest_throw_on_failure.
-TEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) {
+TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
const char* argv[] = {
"foo.exe",
"--gtest_throw_on_failure",
@@ -6345,7 +6376,7 @@
}
// Tests parsing --gtest_throw_on_failure=0.
-TEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) {
+TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
const char* argv[] = {
"foo.exe",
"--gtest_throw_on_failure=0",
@@ -6362,7 +6393,7 @@
// Tests parsing a --gtest_throw_on_failure flag that has a "true"
// definition.
-TEST_F(InitGoogleTestTest, ThrowOnFailureTrue) {
+TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_throw_on_failure=1",
@@ -6377,9 +6408,9 @@
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
}
-#if GTEST_OS_WINDOWS
+# if GTEST_OS_WINDOWS
// Tests parsing wide strings.
-TEST_F(InitGoogleTestTest, WideStrings) {
+TEST_F(ParseFlagsTest, WideStrings) {
const wchar_t* argv[] = {
L"foo.exe",
L"--gtest_filter=Foo*",
@@ -6405,21 +6436,21 @@
# endif // GTEST_OS_WINDOWS
#if GTEST_USE_OWN_FLAGFILE_FLAG_
-class FlagfileTest : public InitGoogleTestTest {
+class FlagfileTest : public ParseFlagsTest {
public:
virtual void SetUp() {
- InitGoogleTestTest::SetUp();
+ ParseFlagsTest::SetUp();
testdata_path_.Set(internal::FilePath(
- internal::TempDir() + internal::GetCurrentExecutableName().string() +
+ testing::TempDir() + internal::GetCurrentExecutableName().string() +
"_flagfile_test"));
testing::internal::posix::RmDir(testdata_path_.c_str());
EXPECT_TRUE(testdata_path_.CreateFolder());
}
virtual void TearDown() {
testing::internal::posix::RmDir(testdata_path_.c_str());
- InitGoogleTestTest::TearDown();
+ ParseFlagsTest::TearDown();
}
internal::FilePath CreateFlagfile(const char* contents) {
@@ -6558,6 +6589,7 @@
} // namespace testing
+
// These two lines test that we can define tests in a namespace that
// has the name "testing" and is nested in another namespace.
namespace my_namespace {
@@ -6638,7 +6670,7 @@
}
#ifdef __BORLANDC__
-// Restores warnings after previous "#pragma option push" supressed them
+// Restores warnings after previous "#pragma option push" suppressed them
# pragma option pop
#endif
@@ -6888,14 +6920,6 @@
StaticAssertTypeEq<int*, IntAlias*>();
}
-TEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) {
- testing::UnitTest* const unit_test = testing::UnitTest::GetInstance();
-
- // We don't have a stack walker in Google Test yet.
- EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str());
- EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str());
-}
-
TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) {
EXPECT_FALSE(HasNonfatalFailure());
}
@@ -7347,7 +7371,7 @@
// Tests for internal utilities necessary for implementation of the universal
// printing.
-// TODO(vladl@google.com): Find a better home for them.
+// FIXME: Find a better home for them.
class ConversionHelperBase {};
class ConversionHelperDerived : public ConversionHelperBase {};
@@ -7531,6 +7555,50 @@
sizeof(IsContainerTest<std::map<int, double> >(0)));
}
+#if GTEST_LANG_CXX11
+struct ConstOnlyContainerWithPointerIterator {
+ using const_iterator = int*;
+ const_iterator begin() const;
+ const_iterator end() const;
+};
+
+struct ConstOnlyContainerWithClassIterator {
+ struct const_iterator {
+ const int& operator*() const;
+ const_iterator& operator++(/* pre-increment */);
+ };
+ const_iterator begin() const;
+ const_iterator end() const;
+};
+
+TEST(IsContainerTestTest, ConstOnlyContainer) {
+ EXPECT_EQ(sizeof(IsContainer),
+ sizeof(IsContainerTest<ConstOnlyContainerWithPointerIterator>(0)));
+ EXPECT_EQ(sizeof(IsContainer),
+ sizeof(IsContainerTest<ConstOnlyContainerWithClassIterator>(0)));
+}
+#endif // GTEST_LANG_CXX11
+
+// Tests IsHashTable.
+struct AHashTable {
+ typedef void hasher;
+};
+struct NotReallyAHashTable {
+ typedef void hasher;
+ typedef void reverse_iterator;
+};
+TEST(IsHashTable, Basic) {
+ EXPECT_TRUE(testing::internal::IsHashTable<AHashTable>::value);
+ EXPECT_FALSE(testing::internal::IsHashTable<NotReallyAHashTable>::value);
+#if GTEST_LANG_CXX11
+ EXPECT_FALSE(testing::internal::IsHashTable<std::vector<int>>::value);
+ EXPECT_TRUE(testing::internal::IsHashTable<std::unordered_set<int>>::value);
+#endif // GTEST_LANG_CXX11
+#if GTEST_HAS_HASH_SET_
+ EXPECT_TRUE(testing::internal::IsHashTable<__gnu_cxx::hash_set<int>>::value);
+#endif // GTEST_HAS_HASH_SET_
+}
+
// Tests ArrayEq().
TEST(ArrayEqTest, WorksForDegeneratedArrays) {
@@ -7704,3 +7772,24 @@
EXPECT_EQ(str, p);
}
+// Tests ad_hoc_test_result().
+
+class AdHocTestResultTest : public testing::Test {
+ protected:
+ static void SetUpTestCase() {
+ FAIL() << "A failure happened inside SetUpTestCase().";
+ }
+};
+
+TEST_F(AdHocTestResultTest, AdHocTestResultForTestCaseShowsFailure) {
+ const testing::TestResult& test_result = testing::UnitTest::GetInstance()
+ ->current_test_case()
+ ->ad_hoc_test_result();
+ EXPECT_TRUE(test_result.Failed());
+}
+
+TEST_F(AdHocTestResultTest, AdHocTestResultTestForUnitTestDoesNotShowFailure) {
+ const testing::TestResult& test_result =
+ testing::UnitTest::GetInstance()->ad_hoc_test_result();
+ EXPECT_FALSE(test_result.Failed());
+}