eson/googletest
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Formatting

Browse Source
This commit is contained in:
Gennadiy Civil 2018-09-23 09:42:11 -07:00 committed by GitHub
parent 6596471104
commit 81c0b876b4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 101 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
googletest/test/gtest_unittest.cc
View File

@ -31,7 +31,7 @@
// Tests for Google Test itself. This verifies that the basic constructs of // Tests for Google Test itself. This verifies that the basic constructs of
// Google Test work. // Google Test work.
#include "third_party/googletest/googletest/include/gtest/gtest.h" #include "gtest/gtest.h"
// Verifies that the command line flag variables can be accessed in // Verifies that the command line flag variables can be accessed in
// code once "gtest.h" has been #included. // code once "gtest.h" has been #included.
@ -65,8 +65,8 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
#include <ostream> #include <ostream>
#include <unordered_set> #include <unordered_set>
#include "third_party/googletest/googletest/include/gtest/gtest-spi.h" #include "gtest/gtest-spi.h"
#include "third_party/googletest/googletest/src/gtest-internal-inl.h" #include "src/gtest-internal-inl.h"
namespace testing { namespace testing {
namespace internal { namespace internal {
@ -5535,7 +5535,7 @@ struct Flags {
// Factory methods. // Factory methods.
// Creates a Flags struct where the gunit_also_run_disabled_tests flag has // Creates a Flags struct where the gtest_also_run_disabled_tests flag has
// the given value. // the given value.
static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) { static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
Flags flags; Flags flags;
@ -5543,7 +5543,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_break_on_failure flag has // Creates a Flags struct where the gtest_break_on_failure flag has
// the given value. // the given value.
static Flags BreakOnFailure(bool break_on_failure) { static Flags BreakOnFailure(bool break_on_failure) {
Flags flags; Flags flags;
@ -5551,7 +5551,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_catch_exceptions flag has // Creates a Flags struct where the gtest_catch_exceptions flag has
// the given value. // the given value.
static Flags CatchExceptions(bool catch_exceptions) { static Flags CatchExceptions(bool catch_exceptions) {
Flags flags; Flags flags;
@ -5559,7 +5559,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_death_test_use_fork flag has // Creates a Flags struct where the gtest_death_test_use_fork flag has
// the given value. // the given value.
static Flags DeathTestUseFork(bool death_test_use_fork) { static Flags DeathTestUseFork(bool death_test_use_fork) {
Flags flags; Flags flags;
@ -5567,7 +5567,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_filter flag has the given // Creates a Flags struct where the gtest_filter flag has the given
// value. // value.
static Flags Filter(const char* filter) { static Flags Filter(const char* filter) {
Flags flags; Flags flags;
@ -5575,7 +5575,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_list_tests flag has the // Creates a Flags struct where the gtest_list_tests flag has the
// given value. // given value.
static Flags ListTests(bool list_tests) { static Flags ListTests(bool list_tests) {
Flags flags; Flags flags;
@ -5583,7 +5583,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_output flag has the given // Creates a Flags struct where the gtest_output flag has the given
// value. // value.
static Flags Output(const char* output) { static Flags Output(const char* output) {
Flags flags; Flags flags;
@ -5591,7 +5591,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_print_time flag has the given // Creates a Flags struct where the gtest_print_time flag has the given
// value. // value.
static Flags PrintTime(bool print_time) { static Flags PrintTime(bool print_time) {
Flags flags; Flags flags;
@ -5599,7 +5599,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_random_seed flag has the given // Creates a Flags struct where the gtest_random_seed flag has the given
// value. // value.
static Flags RandomSeed(Int32 random_seed) { static Flags RandomSeed(Int32 random_seed) {
Flags flags; Flags flags;
@ -5607,7 +5607,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_repeat flag has the given // Creates a Flags struct where the gtest_repeat flag has the given
// value. // value.
static Flags Repeat(Int32 repeat) { static Flags Repeat(Int32 repeat) {
Flags flags; Flags flags;
@ -5615,7 +5615,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_shuffle flag has the given // Creates a Flags struct where the gtest_shuffle flag has the given
// value. // value.
static Flags Shuffle(bool shuffle) { static Flags Shuffle(bool shuffle) {
Flags flags; Flags flags;
@ -5639,7 +5639,7 @@ struct Flags {
return flags; return flags;
} }
// Creates a Flags struct where the gunit_throw_on_failure flag has // Creates a Flags struct where the gtest_throw_on_failure flag has
// the given value. // the given value.
static Flags ThrowOnFailure(bool throw_on_failure) { static Flags ThrowOnFailure(bool throw_on_failure) {
Flags flags; Flags flags;
@ -5799,28 +5799,28 @@ TEST_F(ParseFlagsTest, NoFlag) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
} }
// Tests parsing a bad --gunit_filter flag. // Tests parsing a bad --gtest_filter flag.
TEST_F(ParseFlagsTest, FilterBad) { TEST_F(ParseFlagsTest, FilterBad) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_filter", "--gtest_filter",
NULL NULL
}; };
const char* argv2[] = { const char* argv2[] = {
"foo.exe", "foo.exe",
"--gunit_filter", "--gtest_filter",
NULL NULL
}; };
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
} }
// Tests parsing an empty --gunit_filter flag. // Tests parsing an empty --gtest_filter flag.
TEST_F(ParseFlagsTest, FilterEmpty) { TEST_F(ParseFlagsTest, FilterEmpty) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_filter=", "--gtest_filter=",
NULL NULL
}; };
@ -5832,11 +5832,11 @@ TEST_F(ParseFlagsTest, FilterEmpty) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false);
} }
// Tests parsing a non-empty --gunit_filter flag. // Tests parsing a non-empty --gtest_filter flag.
TEST_F(ParseFlagsTest, FilterNonEmpty) { TEST_F(ParseFlagsTest, FilterNonEmpty) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_filter=abc", "--gtest_filter=abc",
NULL NULL
}; };
@ -5848,11 +5848,11 @@ TEST_F(ParseFlagsTest, FilterNonEmpty) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
} }
// Tests parsing --gunit_break_on_failure. // Tests parsing --gtest_break_on_failure.
TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) { TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_break_on_failure", "--gtest_break_on_failure",
NULL NULL
}; };
@ -5864,11 +5864,11 @@ TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
} }
// Tests parsing --gunit_break_on_failure=0. // Tests parsing --gtest_break_on_failure=0.
TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) { TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_break_on_failure=0", "--gtest_break_on_failure=0",
NULL NULL
}; };
@ -5880,11 +5880,11 @@ TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
} }
// Tests parsing --gunit_break_on_failure=f. // Tests parsing --gtest_break_on_failure=f.
TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) { TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_break_on_failure=f", "--gtest_break_on_failure=f",
NULL NULL
}; };
@ -5896,11 +5896,11 @@ TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
} }
// Tests parsing --gunit_break_on_failure=F. // Tests parsing --gtest_break_on_failure=F.
TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) { TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_break_on_failure=F", "--gtest_break_on_failure=F",
NULL NULL
}; };
@ -5912,12 +5912,12 @@ TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
} }
// Tests parsing a --gunit_break_on_failure flag that has a "true" // Tests parsing a --gtest_break_on_failure flag that has a "true"
// definition. // definition.
TEST_F(ParseFlagsTest, BreakOnFailureTrue) { TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_break_on_failure=1", "--gtest_break_on_failure=1",
NULL NULL
}; };
@ -5929,11 +5929,11 @@ TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
} }
// Tests parsing --gunit_catch_exceptions. // Tests parsing --gtest_catch_exceptions.
TEST_F(ParseFlagsTest, CatchExceptions) { TEST_F(ParseFlagsTest, CatchExceptions) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_catch_exceptions", "--gtest_catch_exceptions",
NULL NULL
}; };
@ -5945,11 +5945,11 @@ TEST_F(ParseFlagsTest, CatchExceptions) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false);
} }
// Tests parsing --gunit_death_test_use_fork. // Tests parsing --gtest_death_test_use_fork.
TEST_F(ParseFlagsTest, DeathTestUseFork) { TEST_F(ParseFlagsTest, DeathTestUseFork) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_death_test_use_fork", "--gtest_death_test_use_fork",
NULL NULL
}; };
@ -5966,8 +5966,8 @@ TEST_F(ParseFlagsTest, DeathTestUseFork) {
TEST_F(ParseFlagsTest, DuplicatedFlags) { TEST_F(ParseFlagsTest, DuplicatedFlags) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_filter=a", "--gtest_filter=a",
"--gunit_filter=b", "--gtest_filter=b",
NULL NULL
}; };
@ -5983,9 +5983,9 @@ TEST_F(ParseFlagsTest, DuplicatedFlags) {
TEST_F(ParseFlagsTest, UnrecognizedFlag) { TEST_F(ParseFlagsTest, UnrecognizedFlag) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_break_on_failure", "--gtest_break_on_failure",
"bar", // Unrecognized by Google Test. "bar", // Unrecognized by Google Test.
"--gunit_filter=b", "--gtest_filter=b",
NULL NULL
}; };
@ -6001,11 +6001,11 @@ TEST_F(ParseFlagsTest, UnrecognizedFlag) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false);
} }
// Tests having a --gunit_list_tests flag // Tests having a --gtest_list_tests flag
TEST_F(ParseFlagsTest, ListTestsFlag) { TEST_F(ParseFlagsTest, ListTestsFlag) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_list_tests", "--gtest_list_tests",
NULL NULL
}; };
@ -6017,11 +6017,11 @@ TEST_F(ParseFlagsTest, ListTestsFlag) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
} }
// Tests having a --gunit_list_tests flag with a "true" value // Tests having a --gtest_list_tests flag with a "true" value
TEST_F(ParseFlagsTest, ListTestsTrue) { TEST_F(ParseFlagsTest, ListTestsTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_list_tests=1", "--gtest_list_tests=1",
NULL NULL
}; };
@ -6033,11 +6033,11 @@ TEST_F(ParseFlagsTest, ListTestsTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
} }
// Tests having a --gunit_list_tests flag with a "false" value // Tests having a --gtest_list_tests flag with a "false" value
TEST_F(ParseFlagsTest, ListTestsFalse) { TEST_F(ParseFlagsTest, ListTestsFalse) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_list_tests=0", "--gtest_list_tests=0",
NULL NULL
}; };
@ -6049,11 +6049,11 @@ TEST_F(ParseFlagsTest, ListTestsFalse) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
} }
// Tests parsing --gunit_list_tests=f. // Tests parsing --gtest_list_tests=f.
TEST_F(ParseFlagsTest, ListTestsFalse_f) { TEST_F(ParseFlagsTest, ListTestsFalse_f) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_list_tests=f", "--gtest_list_tests=f",
NULL NULL
}; };
@ -6065,11 +6065,11 @@ TEST_F(ParseFlagsTest, ListTestsFalse_f) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
} }
// Tests parsing --gunit_list_tests=F. // Tests parsing --gtest_list_tests=F.
TEST_F(ParseFlagsTest, ListTestsFalse_F) { TEST_F(ParseFlagsTest, ListTestsFalse_F) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_list_tests=F", "--gtest_list_tests=F",
NULL NULL
}; };
@ -6081,28 +6081,28 @@ TEST_F(ParseFlagsTest, ListTestsFalse_F) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
} }
// Tests parsing --gunit_output (invalid). // Tests parsing --gtest_output (invalid).
TEST_F(ParseFlagsTest, OutputEmpty) { TEST_F(ParseFlagsTest, OutputEmpty) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_output", "--gtest_output",
NULL NULL
}; };
const char* argv2[] = { const char* argv2[] = {
"foo.exe", "foo.exe",
"--gunit_output", "--gtest_output",
NULL NULL
}; };
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
} }
// Tests parsing --gunit_output=xml // Tests parsing --gtest_output=xml
TEST_F(ParseFlagsTest, OutputXml) { TEST_F(ParseFlagsTest, OutputXml) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_output=xml", "--gtest_output=xml",
NULL NULL
}; };
@ -6114,11 +6114,11 @@ TEST_F(ParseFlagsTest, OutputXml) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false);
} }
// Tests parsing --gunit_output=xml:file // Tests parsing --gtest_output=xml:file
TEST_F(ParseFlagsTest, OutputXmlFile) { TEST_F(ParseFlagsTest, OutputXmlFile) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_output=xml:file", "--gtest_output=xml:file",
NULL NULL
}; };
@ -6130,11 +6130,11 @@ TEST_F(ParseFlagsTest, OutputXmlFile) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false);
} }
// Tests parsing --gunit_output=xml:directory/path/ // Tests parsing --gtest_output=xml:directory/path/
TEST_F(ParseFlagsTest, OutputXmlDirectory) { TEST_F(ParseFlagsTest, OutputXmlDirectory) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_output=xml:directory/path/", "--gtest_output=xml:directory/path/",
NULL NULL
}; };
@ -6147,11 +6147,11 @@ TEST_F(ParseFlagsTest, OutputXmlDirectory) {
Flags::Output("xml:directory/path/"), false); Flags::Output("xml:directory/path/"), false);
} }
// Tests having a --gunit_print_time flag // Tests having a --gtest_print_time flag
TEST_F(ParseFlagsTest, PrintTimeFlag) { TEST_F(ParseFlagsTest, PrintTimeFlag) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_print_time", "--gtest_print_time",
NULL NULL
}; };
@ -6163,11 +6163,11 @@ TEST_F(ParseFlagsTest, PrintTimeFlag) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
} }
// Tests having a --gunit_print_time flag with a "true" value // Tests having a --gtest_print_time flag with a "true" value
TEST_F(ParseFlagsTest, PrintTimeTrue) { TEST_F(ParseFlagsTest, PrintTimeTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_print_time=1", "--gtest_print_time=1",
NULL NULL
}; };
@ -6179,11 +6179,11 @@ TEST_F(ParseFlagsTest, PrintTimeTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
} }
// Tests having a --gunit_print_time flag with a "false" value // Tests having a --gtest_print_time flag with a "false" value
TEST_F(ParseFlagsTest, PrintTimeFalse) { TEST_F(ParseFlagsTest, PrintTimeFalse) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_print_time=0", "--gtest_print_time=0",
NULL NULL
}; };
@ -6195,11 +6195,11 @@ TEST_F(ParseFlagsTest, PrintTimeFalse) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
} }
// Tests parsing --gunit_print_time=f. // Tests parsing --gtest_print_time=f.
TEST_F(ParseFlagsTest, PrintTimeFalse_f) { TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_print_time=f", "--gtest_print_time=f",
NULL NULL
}; };
@ -6211,11 +6211,11 @@ TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
} }
// Tests parsing --gunit_print_time=F. // Tests parsing --gtest_print_time=F.
TEST_F(ParseFlagsTest, PrintTimeFalse_F) { TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_print_time=F", "--gtest_print_time=F",
NULL NULL
}; };
@ -6227,11 +6227,11 @@ TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
} }
// Tests parsing --gunit_random_seed=number // Tests parsing --gtest_random_seed=number
TEST_F(ParseFlagsTest, RandomSeed) { TEST_F(ParseFlagsTest, RandomSeed) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_random_seed=1000", "--gtest_random_seed=1000",
NULL NULL
}; };
@ -6243,11 +6243,11 @@ TEST_F(ParseFlagsTest, RandomSeed) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false);
} }
// Tests parsing --gunit_repeat=number // Tests parsing --gtest_repeat=number
TEST_F(ParseFlagsTest, Repeat) { TEST_F(ParseFlagsTest, Repeat) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_repeat=1000", "--gtest_repeat=1000",
NULL NULL
}; };
@ -6259,11 +6259,11 @@ TEST_F(ParseFlagsTest, Repeat) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false);
} }
// Tests having a --gunit_also_run_disabled_tests flag // Tests having a --gtest_also_run_disabled_tests flag
TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) { TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_also_run_disabled_tests", "--gtest_also_run_disabled_tests",
NULL NULL
}; };
@ -6276,11 +6276,11 @@ TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
Flags::AlsoRunDisabledTests(true), false); Flags::AlsoRunDisabledTests(true), false);
} }
// Tests having a --gunit_also_run_disabled_tests flag with a "true" value // Tests having a --gtest_also_run_disabled_tests flag with a "true" value
TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) { TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_also_run_disabled_tests=1", "--gtest_also_run_disabled_tests=1",
NULL NULL
}; };
@ -6293,11 +6293,11 @@ TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
Flags::AlsoRunDisabledTests(true), false); Flags::AlsoRunDisabledTests(true), false);
} }
// Tests having a --gunit_also_run_disabled_tests flag with a "false" value // Tests having a --gtest_also_run_disabled_tests flag with a "false" value
TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) { TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_also_run_disabled_tests=0", "--gtest_also_run_disabled_tests=0",
NULL NULL
}; };
@ -6310,11 +6310,11 @@ TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
Flags::AlsoRunDisabledTests(false), false); Flags::AlsoRunDisabledTests(false), false);
} }
// Tests parsing --gunit_shuffle. // Tests parsing --gtest_shuffle.
TEST_F(ParseFlagsTest, ShuffleWithoutValue) { TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_shuffle", "--gtest_shuffle",
NULL NULL
}; };
@ -6326,11 +6326,11 @@ TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
} }
// Tests parsing --gunit_shuffle=0. // Tests parsing --gtest_shuffle=0.
TEST_F(ParseFlagsTest, ShuffleFalse_0) { TEST_F(ParseFlagsTest, ShuffleFalse_0) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_shuffle=0", "--gtest_shuffle=0",
NULL NULL
}; };
@ -6342,11 +6342,11 @@ TEST_F(ParseFlagsTest, 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 --gunit_shuffle flag that has a "true" definition. // Tests parsing a --gtest_shuffle flag that has a "true" definition.
TEST_F(ParseFlagsTest, ShuffleTrue) { TEST_F(ParseFlagsTest, ShuffleTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_shuffle=1", "--gtest_shuffle=1",
NULL NULL
}; };
@ -6358,11 +6358,11 @@ TEST_F(ParseFlagsTest, ShuffleTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
} }
// Tests parsing --gunit_stack_trace_depth=number. // Tests parsing --gtest_stack_trace_depth=number.
TEST_F(ParseFlagsTest, StackTraceDepth) { TEST_F(ParseFlagsTest, StackTraceDepth) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_stack_trace_depth=5", "--gtest_stack_trace_depth=5",
NULL NULL
}; };
@ -6377,7 +6377,7 @@ TEST_F(ParseFlagsTest, StackTraceDepth) {
TEST_F(ParseFlagsTest, StreamResultTo) { TEST_F(ParseFlagsTest, StreamResultTo) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_stream_result_to=localhost:1234", "--gtest_stream_result_to=localhost:1234",
NULL NULL
}; };
@ -6390,11 +6390,11 @@ TEST_F(ParseFlagsTest, StreamResultTo) {
argv, argv2, Flags::StreamResultTo("localhost:1234"), false); argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
} }
// Tests parsing --gunit_throw_on_failure. // Tests parsing --gtest_throw_on_failure.
TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) { TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_throw_on_failure", "--gtest_throw_on_failure",
NULL NULL
}; };
@ -6406,11 +6406,11 @@ TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
} }
// Tests parsing --gunit_throw_on_failure=0. // Tests parsing --gtest_throw_on_failure=0.
TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) { TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_throw_on_failure=0", "--gtest_throw_on_failure=0",
NULL NULL
}; };
@ -6422,12 +6422,12 @@ TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false);
} }
// Tests parsing a --gunit_throw_on_failure flag that has a "true" // Tests parsing a --gtest_throw_on_failure flag that has a "true"
// definition. // definition.
TEST_F(ParseFlagsTest, ThrowOnFailureTrue) { TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
const char* argv[] = { const char* argv[] = {
"foo.exe", "foo.exe",
"--gunit_throw_on_failure=1", "--gtest_throw_on_failure=1",
NULL NULL
}; };
@ -6444,16 +6444,16 @@ TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
TEST_F(ParseFlagsTest, WideStrings) { TEST_F(ParseFlagsTest, WideStrings) {
const wchar_t* argv[] = { const wchar_t* argv[] = {
L"foo.exe", L"foo.exe",
L"--gunit_filter=Foo*", L"--gtest_filter=Foo*",
L"--gunit_list_tests=1", L"--gtest_list_tests=1",
L"--gunit_break_on_failure", L"--gtest_break_on_failure",
L"--non_gunit_flag", L"--non_gtest_flag",
NULL NULL
}; };
const wchar_t* argv2[] = { const wchar_t* argv2[] = {
L"foo.exe", L"foo.exe",
L"--non_gunit_flag", L"--non_gtest_flag",
NULL NULL
}; };
@ -6517,7 +6517,7 @@ TEST_F(FlagfileTest, Empty) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
} }
// Tests passing a non-empty --gunit_filter flag via --gunit_flagfile. // Tests passing a non-empty --gtest_filter flag via --gtest_flagfile.
TEST_F(FlagfileTest, FilterNonEmpty) { TEST_F(FlagfileTest, FilterNonEmpty) {
internal::FilePath flagfile_path(CreateFlagfile( internal::FilePath flagfile_path(CreateFlagfile(
"--" GTEST_FLAG_PREFIX_ "filter=abc")); "--" GTEST_FLAG_PREFIX_ "filter=abc"));
@ -6538,7 +6538,7 @@ TEST_F(FlagfileTest, FilterNonEmpty) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
} }
// Tests passing several flags via --gunit_flagfile. // Tests passing several flags via --gtest_flagfile.
TEST_F(FlagfileTest, SeveralFlags) { TEST_F(FlagfileTest, SeveralFlags) {
internal::FilePath flagfile_path(CreateFlagfile( internal::FilePath flagfile_path(CreateFlagfile(
"--" GTEST_FLAG_PREFIX_ "filter=abc\n" "--" GTEST_FLAG_PREFIX_ "filter=abc\n"