3party/googletest
0
0
Fork 0
mirror of https://github.com/google/googletest.git synced 2025-01-17 04:58:08 +08:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into master

Browse Source
This commit is contained in:
Gennadiy Civil 2018-02-26 11:14:34 -05:00 committed by GitHub
commit aa31660d18
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 86 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
googletest/docs/Primer.md
View File

@ -239,7 +239,7 @@ To create a test:
1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds. 1. The test's result is determined by the assertions; if any assertion in the test fails (either fatally or non-fatally), or if the test crashes, the entire test fails. Otherwise, it succeeds.
``` ```
TEST(test_case_name, test_name) { TEST(testCaseName, testName) {
... test body ... ... test body ...
} }
``` ```

179
googletest/test/gtest_unittest.cc
View File

@ -2088,7 +2088,7 @@ class UnitTestRecordPropertyTestEnvironment : public Environment {
}; };
// This will test property recording outside of any test or test case. // This will test property recording outside of any test or test case.
Environment* record_property_env GTEST_ATTRIBUTE_UNUSED_ = static Environment* record_property_env =
AddGlobalTestEnvironment(new UnitTestRecordPropertyTestEnvironment); AddGlobalTestEnvironment(new UnitTestRecordPropertyTestEnvironment);
// This group of tests is for predicate assertions (ASSERT_PRED*, etc) // This group of tests is for predicate assertions (ASSERT_PRED*, etc)
@ -2421,9 +2421,8 @@ TEST(StringAssertionTest, ASSERT_STREQ) {
const char p2[] = "good"; const char p2[] = "good";
ASSERT_STREQ(p1, p2); ASSERT_STREQ(p1, p2);
EXPECT_FATAL_FAILURE( EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
ASSERT_STREQ("bad", "good"), " \"bad\"\n \"good\"");
"Expected equality of these values:\n \"bad\"\n \"good\"");
} }
// Tests ASSERT_STREQ with NULL arguments. // Tests ASSERT_STREQ with NULL arguments.
@ -3361,7 +3360,7 @@ class NoFatalFailureTest : public Test {
void DoAssertNoFatalFailureOnFails() { void DoAssertNoFatalFailureOnFails() {
ASSERT_NO_FATAL_FAILURE(Fails()); ASSERT_NO_FATAL_FAILURE(Fails());
ADD_FAILURE() << "shold not reach here."; ADD_FAILURE() << "should not reach here.";
} }
void DoExpectNoFatalFailureOnFails() { void DoExpectNoFatalFailureOnFails() {
@ -3813,7 +3812,7 @@ void TestEq1(int x) {
// Tests calling a test subroutine that's not part of a fixture. // Tests calling a test subroutine that's not part of a fixture.
TEST(AssertionTest, NonFixtureSubroutine) { TEST(AssertionTest, NonFixtureSubroutine) {
EXPECT_FATAL_FAILURE(TestEq1(2), EXPECT_FATAL_FAILURE(TestEq1(2),
"Which is: 2"); " x\n Which is: 2");
} }
// An uncopyable class. // An uncopyable class.
@ -3952,13 +3951,13 @@ TEST(AssertionTest, AnonymousEnum) {
// ICE's in C++Builder. // ICE's in C++Builder.
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB), EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
"kCaseB"); " kCaseB\n Which is: ");
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
"Which is: 42"); "\n Which is: 42");
# endif # endif
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
"Which is: -1"); "\n Which is: -1");
} }
#endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC) #endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
@ -4426,7 +4425,7 @@ TEST(ExpectTest, EXPECT_EQ_NULL) {
// A failure. // A failure.
int n = 0; int n = 0;
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n), EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
"&n\n"); " &n\n Which is:");
} }
#endif // GTEST_CAN_COMPARE_NULL #endif // GTEST_CAN_COMPARE_NULL
@ -4442,7 +4441,7 @@ TEST(ExpectTest, EXPECT_EQ_0) {
// A failure. // A failure.
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6), EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
"Expected equality of these values:\n 0\n 5.6"); " 0\n 5.6");
} }
// Tests EXPECT_NE. // Tests EXPECT_NE.
@ -4542,7 +4541,7 @@ TEST(ExpectTest, EXPECT_ANY_THROW) {
TEST(ExpectTest, ExpectPrecedence) { TEST(ExpectTest, ExpectPrecedence) {
EXPECT_EQ(1 < 2, true); EXPECT_EQ(1 < 2, true);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false), EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),
"true && false"); " true && false\n Which is: false");
} }
@ -4689,14 +4688,14 @@ TEST(EqAssertionTest, Bool) {
EXPECT_FATAL_FAILURE({ EXPECT_FATAL_FAILURE({
bool false_value = false; bool false_value = false;
ASSERT_EQ(false_value, true); ASSERT_EQ(false_value, true);
}, "Which is: false"); }, " false_value\n Which is: false\n true");
} }
// Tests using int values in {EXPECT|ASSERT}_EQ. // Tests using int values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest, Int) { TEST(EqAssertionTest, Int) {
ASSERT_EQ(32, 32); ASSERT_EQ(32, 32);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33), EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),
"33"); " 32\n 33");
} }
// Tests using time_t values in {EXPECT|ASSERT}_EQ. // Tests using time_t values in {EXPECT|ASSERT}_EQ.
@ -4713,9 +4712,9 @@ TEST(EqAssertionTest, Char) {
ASSERT_EQ('z', 'z'); ASSERT_EQ('z', 'z');
const char ch = 'b'; const char ch = 'b';
EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch), EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),
"ch"); " ch\n Which is: 'b'");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch), EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),
"ch"); " ch\n Which is: 'b'");
} }
// Tests using wchar_t values in {EXPECT|ASSERT}_EQ. // Tests using wchar_t values in {EXPECT|ASSERT}_EQ.
@ -4735,7 +4734,7 @@ TEST(EqAssertionTest, WideChar) {
"wchar"); "wchar");
wchar = 0x8119; wchar = 0x8119;
EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar), EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
"wchar"); " wchar\n Which is: L'");
} }
// Tests using ::std::string values in {EXPECT|ASSERT}_EQ. // Tests using ::std::string values in {EXPECT|ASSERT}_EQ.
@ -4764,8 +4763,7 @@ TEST(EqAssertionTest, StdString) {
static ::std::string str3(str1); static ::std::string str3(str1);
str3.at(2) = '\0'; str3.at(2) = '\0';
EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3), EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),
" str3\n" " str3\n Which is: \"A \\0 in the middle\"");
" Which is: \"A \\0 in the middle\"");
} }
#if GTEST_HAS_STD_WSTRING #if GTEST_HAS_STD_WSTRING
@ -4885,9 +4883,9 @@ TEST(EqAssertionTest, CharPointer) {
ASSERT_EQ(p1, p1); ASSERT_EQ(p1, p1);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
"p2"); " p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
"p2"); " p2\n Which is:");
EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234), EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
reinterpret_cast<char*>(0xABC0)), reinterpret_cast<char*>(0xABC0)),
"ABC0"); "ABC0");
@ -4907,9 +4905,9 @@ TEST(EqAssertionTest, WideCharPointer) {
EXPECT_EQ(p0, p0); EXPECT_EQ(p0, p0);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
"p2"); " p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
"p2"); " p2\n Which is:");
void* pv3 = (void*)0x1234; // NOLINT void* pv3 = (void*)0x1234; // NOLINT
void* pv4 = (void*)0xABC0; // NOLINT void* pv4 = (void*)0xABC0; // NOLINT
const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3); const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);
@ -5454,7 +5452,8 @@ TEST_F(SetUpTestCaseTest, Test2) {
EXPECT_STREQ("123", shared_resource_); 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. // The Flags struct stores a copy of all Google Test flags.
struct Flags { struct Flags {
@ -5540,8 +5539,8 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gtest_random_seed flag has // Creates a Flags struct where the gtest_random_seed flag has the given
// the given value. // value.
static Flags RandomSeed(Int32 random_seed) { static Flags RandomSeed(Int32 random_seed) {
Flags flags; Flags flags;
flags.random_seed = random_seed; flags.random_seed = random_seed;
@ -5556,8 +5555,8 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gtest_shuffle flag has // Creates a Flags struct where the gtest_shuffle flag has the given
// the given value. // value.
static Flags Shuffle(bool shuffle) { static Flags Shuffle(bool shuffle) {
Flags flags; Flags flags;
flags.shuffle = shuffle; flags.shuffle = shuffle;
@ -5605,8 +5604,8 @@ struct Flags {
bool throw_on_failure; bool throw_on_failure;
}; };
// Fixture for testing InitGoogleTest(). // Fixture for testing ParseGoogleTestFlagsOnly().
class InitGoogleTestTest : public Test { class ParseFlagsTest : public Test {
protected: protected:
// Clears the flags before each test. // Clears the flags before each test.
virtual void SetUp() { virtual void SetUp() {
@ -5667,16 +5666,16 @@ class InitGoogleTestTest : public Test {
const bool saved_help_flag = ::testing::internal::g_help_flag; const bool saved_help_flag = ::testing::internal::g_help_flag;
::testing::internal::g_help_flag = false; ::testing::internal::g_help_flag = false;
#if GTEST_HAS_STREAM_REDIRECTION # if GTEST_HAS_STREAM_REDIRECTION
CaptureStdout(); CaptureStdout();
#endif # endif
// Parses the command line. // Parses the command line.
internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1)); internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
#if GTEST_HAS_STREAM_REDIRECTION # if GTEST_HAS_STREAM_REDIRECTION
const std::string captured_stdout = GetCapturedStdout(); const std::string captured_stdout = GetCapturedStdout();
#endif # endif
// Verifies the flag values. // Verifies the flag values.
CheckFlags(expected); CheckFlags(expected);
@ -5689,7 +5688,7 @@ class InitGoogleTestTest : public Test {
// help message for the flags it recognizes. // help message for the flags it recognizes.
EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag); 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 = const char* const expected_help_fragment =
"This program contains tests written using"; "This program contains tests written using";
if (should_print_help) { if (should_print_help) {
@ -5698,7 +5697,7 @@ class InitGoogleTestTest : public Test {
EXPECT_PRED_FORMAT2(IsNotSubstring, EXPECT_PRED_FORMAT2(IsNotSubstring,
expected_help_fragment, captured_stdout); expected_help_fragment, captured_stdout);
} }
#endif // GTEST_HAS_STREAM_REDIRECTION # endif // GTEST_HAS_STREAM_REDIRECTION
::testing::internal::g_help_flag = saved_help_flag; ::testing::internal::g_help_flag = saved_help_flag;
} }
@ -5706,14 +5705,14 @@ class InitGoogleTestTest : public Test {
// This macro wraps TestParsingFlags s.t. the user doesn't need // This macro wraps TestParsingFlags s.t. the user doesn't need
// to specify the array sizes. // 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, \ TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
sizeof(argv2)/sizeof(*argv2) - 1, argv2, \ sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
expected, should_print_help) expected, should_print_help)
}; };
// Tests parsing an empty command line. // Tests parsing an empty command line.
TEST_F(InitGoogleTestTest, Empty) { TEST_F(ParseFlagsTest, Empty) {
const char* argv[] = { const char* argv[] = {
NULL NULL
}; };
@ -5726,7 +5725,7 @@ TEST_F(InitGoogleTestTest, Empty) {
} }
// Tests parsing a command line that has no flag. // Tests parsing a command line that has no flag.
TEST_F(InitGoogleTestTest, NoFlag) { TEST_F(ParseFlagsTest, NoFlag) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
NULL NULL
@ -5741,7 +5740,7 @@ TEST_F(InitGoogleTestTest, NoFlag) {
} }
// Tests parsing a bad --gtest_filter flag. // Tests parsing a bad --gtest_filter flag.
TEST_F(InitGoogleTestTest, FilterBad) { TEST_F(ParseFlagsTest, FilterBad) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_filter", "--gtest_filter",
@ -5758,7 +5757,7 @@ TEST_F(InitGoogleTestTest, FilterBad) {
} }
// Tests parsing an empty --gtest_filter flag. // Tests parsing an empty --gtest_filter flag.
TEST_F(InitGoogleTestTest, FilterEmpty) { TEST_F(ParseFlagsTest, FilterEmpty) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_filter=", "--gtest_filter=",
@ -5774,7 +5773,7 @@ TEST_F(InitGoogleTestTest, FilterEmpty) {
} }
// Tests parsing a non-empty --gtest_filter flag. // Tests parsing a non-empty --gtest_filter flag.
TEST_F(InitGoogleTestTest, FilterNonEmpty) { TEST_F(ParseFlagsTest, FilterNonEmpty) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_filter=abc", "--gtest_filter=abc",
@ -5790,7 +5789,7 @@ TEST_F(InitGoogleTestTest, FilterNonEmpty) {
} }
// Tests parsing --gtest_break_on_failure. // Tests parsing --gtest_break_on_failure.
TEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) { TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_break_on_failure", "--gtest_break_on_failure",
@ -5806,7 +5805,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) {
} }
// Tests parsing --gtest_break_on_failure=0. // Tests parsing --gtest_break_on_failure=0.
TEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) { TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_break_on_failure=0", "--gtest_break_on_failure=0",
@ -5822,7 +5821,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) {
} }
// Tests parsing --gtest_break_on_failure=f. // Tests parsing --gtest_break_on_failure=f.
TEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) { TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_break_on_failure=f", "--gtest_break_on_failure=f",
@ -5838,7 +5837,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) {
} }
// Tests parsing --gtest_break_on_failure=F. // Tests parsing --gtest_break_on_failure=F.
TEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) { TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_break_on_failure=F", "--gtest_break_on_failure=F",
@ -5855,7 +5854,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) {
// Tests parsing a --gtest_break_on_failure flag that has a "true" // Tests parsing a --gtest_break_on_failure flag that has a "true"
// definition. // definition.
TEST_F(InitGoogleTestTest, BreakOnFailureTrue) { TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_break_on_failure=1", "--gtest_break_on_failure=1",
@ -5871,7 +5870,7 @@ TEST_F(InitGoogleTestTest, BreakOnFailureTrue) {
} }
// Tests parsing --gtest_catch_exceptions. // Tests parsing --gtest_catch_exceptions.
TEST_F(InitGoogleTestTest, CatchExceptions) { TEST_F(ParseFlagsTest, CatchExceptions) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_catch_exceptions", "--gtest_catch_exceptions",
@ -5887,7 +5886,7 @@ TEST_F(InitGoogleTestTest, CatchExceptions) {
} }
// Tests parsing --gtest_death_test_use_fork. // Tests parsing --gtest_death_test_use_fork.
TEST_F(InitGoogleTestTest, DeathTestUseFork) { TEST_F(ParseFlagsTest, DeathTestUseFork) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_death_test_use_fork", "--gtest_death_test_use_fork",
@ -5904,7 +5903,7 @@ TEST_F(InitGoogleTestTest, DeathTestUseFork) {
// Tests having the same flag twice with different values. The // Tests having the same flag twice with different values. The
// expected behavior is that the one coming last takes precedence. // expected behavior is that the one coming last takes precedence.
TEST_F(InitGoogleTestTest, DuplicatedFlags) { TEST_F(ParseFlagsTest, DuplicatedFlags) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_filter=a", "--gtest_filter=a",
@ -5921,7 +5920,7 @@ TEST_F(InitGoogleTestTest, DuplicatedFlags) {
} }
// Tests having an unrecognized flag on the command line. // Tests having an unrecognized flag on the command line.
TEST_F(InitGoogleTestTest, UnrecognizedFlag) { TEST_F(ParseFlagsTest, UnrecognizedFlag) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_break_on_failure", "--gtest_break_on_failure",
@ -5943,7 +5942,7 @@ TEST_F(InitGoogleTestTest, UnrecognizedFlag) {
} }
// Tests having a --gtest_list_tests flag // Tests having a --gtest_list_tests flag
TEST_F(InitGoogleTestTest, ListTestsFlag) { TEST_F(ParseFlagsTest, ListTestsFlag) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_list_tests", "--gtest_list_tests",
@ -5959,7 +5958,7 @@ TEST_F(InitGoogleTestTest, ListTestsFlag) {
} }
// Tests having a --gtest_list_tests flag with a "true" value // Tests having a --gtest_list_tests flag with a "true" value
TEST_F(InitGoogleTestTest, ListTestsTrue) { TEST_F(ParseFlagsTest, ListTestsTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_list_tests=1", "--gtest_list_tests=1",
@ -5975,7 +5974,7 @@ TEST_F(InitGoogleTestTest, ListTestsTrue) {
} }
// Tests having a --gtest_list_tests flag with a "false" value // Tests having a --gtest_list_tests flag with a "false" value
TEST_F(InitGoogleTestTest, ListTestsFalse) { TEST_F(ParseFlagsTest, ListTestsFalse) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_list_tests=0", "--gtest_list_tests=0",
@ -5991,7 +5990,7 @@ TEST_F(InitGoogleTestTest, ListTestsFalse) {
} }
// Tests parsing --gtest_list_tests=f. // Tests parsing --gtest_list_tests=f.
TEST_F(InitGoogleTestTest, ListTestsFalse_f) { TEST_F(ParseFlagsTest, ListTestsFalse_f) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_list_tests=f", "--gtest_list_tests=f",
@ -6007,7 +6006,7 @@ TEST_F(InitGoogleTestTest, ListTestsFalse_f) {
} }
// Tests parsing --gtest_list_tests=F. // Tests parsing --gtest_list_tests=F.
TEST_F(InitGoogleTestTest, ListTestsFalse_F) { TEST_F(ParseFlagsTest, ListTestsFalse_F) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_list_tests=F", "--gtest_list_tests=F",
@ -6023,7 +6022,7 @@ TEST_F(InitGoogleTestTest, ListTestsFalse_F) {
} }
// Tests parsing --gtest_output (invalid). // Tests parsing --gtest_output (invalid).
TEST_F(InitGoogleTestTest, OutputEmpty) { TEST_F(ParseFlagsTest, OutputEmpty) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_output", "--gtest_output",
@ -6040,7 +6039,7 @@ TEST_F(InitGoogleTestTest, OutputEmpty) {
} }
// Tests parsing --gtest_output=xml // Tests parsing --gtest_output=xml
TEST_F(InitGoogleTestTest, OutputXml) { TEST_F(ParseFlagsTest, OutputXml) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_output=xml", "--gtest_output=xml",
@ -6056,7 +6055,7 @@ TEST_F(InitGoogleTestTest, OutputXml) {
} }
// Tests parsing --gtest_output=xml:file // Tests parsing --gtest_output=xml:file
TEST_F(InitGoogleTestTest, OutputXmlFile) { TEST_F(ParseFlagsTest, OutputXmlFile) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_output=xml:file", "--gtest_output=xml:file",
@ -6072,7 +6071,7 @@ TEST_F(InitGoogleTestTest, OutputXmlFile) {
} }
// Tests parsing --gtest_output=xml:directory/path/ // Tests parsing --gtest_output=xml:directory/path/
TEST_F(InitGoogleTestTest, OutputXmlDirectory) { TEST_F(ParseFlagsTest, OutputXmlDirectory) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_output=xml:directory/path/", "--gtest_output=xml:directory/path/",
@ -6089,7 +6088,7 @@ TEST_F(InitGoogleTestTest, OutputXmlDirectory) {
} }
// Tests having a --gtest_print_time flag // Tests having a --gtest_print_time flag
TEST_F(InitGoogleTestTest, PrintTimeFlag) { TEST_F(ParseFlagsTest, PrintTimeFlag) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_print_time", "--gtest_print_time",
@ -6105,7 +6104,7 @@ TEST_F(InitGoogleTestTest, PrintTimeFlag) {
} }
// Tests having a --gtest_print_time flag with a "true" value // Tests having a --gtest_print_time flag with a "true" value
TEST_F(InitGoogleTestTest, PrintTimeTrue) { TEST_F(ParseFlagsTest, PrintTimeTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_print_time=1", "--gtest_print_time=1",
@ -6121,7 +6120,7 @@ TEST_F(InitGoogleTestTest, PrintTimeTrue) {
} }
// Tests having a --gtest_print_time flag with a "false" value // Tests having a --gtest_print_time flag with a "false" value
TEST_F(InitGoogleTestTest, PrintTimeFalse) { TEST_F(ParseFlagsTest, PrintTimeFalse) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_print_time=0", "--gtest_print_time=0",
@ -6137,7 +6136,7 @@ TEST_F(InitGoogleTestTest, PrintTimeFalse) {
} }
// Tests parsing --gtest_print_time=f. // Tests parsing --gtest_print_time=f.
TEST_F(InitGoogleTestTest, PrintTimeFalse_f) { TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_print_time=f", "--gtest_print_time=f",
@ -6153,7 +6152,7 @@ TEST_F(InitGoogleTestTest, PrintTimeFalse_f) {
} }
// Tests parsing --gtest_print_time=F. // Tests parsing --gtest_print_time=F.
TEST_F(InitGoogleTestTest, PrintTimeFalse_F) { TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_print_time=F", "--gtest_print_time=F",
@ -6169,7 +6168,7 @@ TEST_F(InitGoogleTestTest, PrintTimeFalse_F) {
} }
// Tests parsing --gtest_random_seed=number // Tests parsing --gtest_random_seed=number
TEST_F(InitGoogleTestTest, RandomSeed) { TEST_F(ParseFlagsTest, RandomSeed) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_random_seed=1000", "--gtest_random_seed=1000",
@ -6185,7 +6184,7 @@ TEST_F(InitGoogleTestTest, RandomSeed) {
} }
// Tests parsing --gtest_repeat=number // Tests parsing --gtest_repeat=number
TEST_F(InitGoogleTestTest, Repeat) { TEST_F(ParseFlagsTest, Repeat) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_repeat=1000", "--gtest_repeat=1000",
@ -6201,7 +6200,7 @@ TEST_F(InitGoogleTestTest, Repeat) {
} }
// Tests having a --gtest_also_run_disabled_tests flag // Tests having a --gtest_also_run_disabled_tests flag
TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) { TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_also_run_disabled_tests", "--gtest_also_run_disabled_tests",
@ -6218,7 +6217,7 @@ TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) {
} }
// Tests having a --gtest_also_run_disabled_tests flag with a "true" value // Tests having a --gtest_also_run_disabled_tests flag with a "true" value
TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) { TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_also_run_disabled_tests=1", "--gtest_also_run_disabled_tests=1",
@ -6235,7 +6234,7 @@ TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) {
} }
// Tests having a --gtest_also_run_disabled_tests flag with a "false" value // Tests having a --gtest_also_run_disabled_tests flag with a "false" value
TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) { TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_also_run_disabled_tests=0", "--gtest_also_run_disabled_tests=0",
@ -6252,7 +6251,7 @@ TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) {
} }
// Tests parsing --gtest_shuffle. // Tests parsing --gtest_shuffle.
TEST_F(InitGoogleTestTest, ShuffleWithoutValue) { TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_shuffle", "--gtest_shuffle",
@ -6268,7 +6267,7 @@ TEST_F(InitGoogleTestTest, ShuffleWithoutValue) {
} }
// Tests parsing --gtest_shuffle=0. // Tests parsing --gtest_shuffle=0.
TEST_F(InitGoogleTestTest, ShuffleFalse_0) { TEST_F(ParseFlagsTest, ShuffleFalse_0) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_shuffle=0", "--gtest_shuffle=0",
@ -6283,9 +6282,8 @@ TEST_F(InitGoogleTestTest, ShuffleFalse_0) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false);
} }
// Tests parsing a --gtest_shuffle flag that has a "true" // Tests parsing a --gtest_shuffle flag that has a "true" definition.
// definition. TEST_F(ParseFlagsTest, ShuffleTrue) {
TEST_F(InitGoogleTestTest, ShuffleTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_shuffle=1", "--gtest_shuffle=1",
@ -6301,7 +6299,7 @@ TEST_F(InitGoogleTestTest, ShuffleTrue) {
} }
// Tests parsing --gtest_stack_trace_depth=number. // Tests parsing --gtest_stack_trace_depth=number.
TEST_F(InitGoogleTestTest, StackTraceDepth) { TEST_F(ParseFlagsTest, StackTraceDepth) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_stack_trace_depth=5", "--gtest_stack_trace_depth=5",
@ -6316,7 +6314,7 @@ TEST_F(InitGoogleTestTest, StackTraceDepth) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);
} }
TEST_F(InitGoogleTestTest, StreamResultTo) { TEST_F(ParseFlagsTest, StreamResultTo) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_stream_result_to=localhost:1234", "--gtest_stream_result_to=localhost:1234",
@ -6333,7 +6331,7 @@ TEST_F(InitGoogleTestTest, StreamResultTo) {
} }
// Tests parsing --gtest_throw_on_failure. // Tests parsing --gtest_throw_on_failure.
TEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) { TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_throw_on_failure", "--gtest_throw_on_failure",
@ -6349,7 +6347,7 @@ TEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) {
} }
// Tests parsing --gtest_throw_on_failure=0. // Tests parsing --gtest_throw_on_failure=0.
TEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) { TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_throw_on_failure=0", "--gtest_throw_on_failure=0",
@ -6366,7 +6364,7 @@ TEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) {
// Tests parsing a --gtest_throw_on_failure flag that has a "true" // Tests parsing a --gtest_throw_on_failure flag that has a "true"
// definition. // definition.
TEST_F(InitGoogleTestTest, ThrowOnFailureTrue) { TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gtest_throw_on_failure=1", "--gtest_throw_on_failure=1",
@ -6381,9 +6379,9 @@ TEST_F(InitGoogleTestTest, ThrowOnFailureTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
} }
#if GTEST_OS_WINDOWS # if GTEST_OS_WINDOWS
// Tests parsing wide strings. // Tests parsing wide strings.
TEST_F(InitGoogleTestTest, WideStrings) { TEST_F(ParseFlagsTest, WideStrings) {
const wchar_t* argv[] = { const wchar_t* argv[] = {
L"foo.exe", L"foo.exe",
L"--gtest_filter=Foo*", L"--gtest_filter=Foo*",
@ -6409,10 +6407,10 @@ TEST_F(InitGoogleTestTest, WideStrings) {
# endif // GTEST_OS_WINDOWS # endif // GTEST_OS_WINDOWS
#if GTEST_USE_OWN_FLAGFILE_FLAG_ #if GTEST_USE_OWN_FLAGFILE_FLAG_
class FlagfileTest : public InitGoogleTestTest { class FlagfileTest : public ParseFlagsTest {
public: public:
virtual void SetUp() { virtual void SetUp() {
InitGoogleTestTest::SetUp(); ParseFlagsTest::SetUp();
testdata_path_.Set(internal::FilePath( testdata_path_.Set(internal::FilePath(
testing::TempDir() + internal::GetCurrentExecutableName().string() + testing::TempDir() + internal::GetCurrentExecutableName().string() +
@ -6423,7 +6421,7 @@ class FlagfileTest : public InitGoogleTestTest {
virtual void TearDown() { virtual void TearDown() {
testing::internal::posix::RmDir(testdata_path_.c_str()); testing::internal::posix::RmDir(testdata_path_.c_str());
InitGoogleTestTest::TearDown(); ParseFlagsTest::TearDown();
} }
internal::FilePath CreateFlagfile(const char* contents) { internal::FilePath CreateFlagfile(const char* contents) {
@ -6562,6 +6560,7 @@ TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) {
} // namespace testing } // namespace testing
// These two lines test that we can define tests in a namespace that // These two lines test that we can define tests in a namespace that
// has the name "testing" and is nested in another namespace. // has the name "testing" and is nested in another namespace.
namespace my_namespace { namespace my_namespace {
@ -6892,14 +6891,6 @@ TEST(StaticAssertTypeEqTest, CompilesForEqualTypes) {
StaticAssertTypeEq<int*, IntAlias*>(); 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) { TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) {
EXPECT_FALSE(HasNonfatalFailure()); EXPECT_FALSE(HasNonfatalFailure());
} }
@ -7659,7 +7650,7 @@ TEST(NativeArrayTest, MethodsWork) {
EXPECT_EQ(0, *it); EXPECT_EQ(0, *it);
++it; ++it;
EXPECT_EQ(1, *it); EXPECT_EQ(1, *it);
++it; it++;
EXPECT_EQ(2, *it); EXPECT_EQ(2, *it);
++it; ++it;
EXPECT_EQ(na.end(), it); EXPECT_EQ(na.end(), it);