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:35:25 -07:00 committed by GitHub
parent f335c30660
commit fca8f23b89
1 changed files with 118 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

232
googletest/test/gtest_unittest.cc
View File

@ -31,7 +31,7 @@
// Tests for Google Test itself. This verifies that the basic constructs of
// Google Test work.
#include "gtest/gtest.h"
#include "third_party/googletest/googletest/include/gtest/gtest.h"
// Verifies that the command line flag variables can be accessed in
// code once "gtest.h" has been #included.
@ -65,8 +65,8 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
#include <ostream>
#include <unordered_set>
#include "gtest/gtest-spi.h"
#include "src/gtest-internal-inl.h"
#include "third_party/googletest/googletest/include/gtest/gtest-spi.h"
#include "third_party/googletest/googletest/src/gtest-internal-inl.h"
namespace testing {
namespace internal {
@ -3328,9 +3328,7 @@ TEST_F(SingleEvaluationTest, OtherCases) {
void ThrowAnInteger() {
throw 1;
}
void ThrowAnException(const char* what) {
throw std::runtime_error(what);
}
void ThrowAnException(const char* what) { throw std::runtime_error(what); }
// Tests that assertion arguments are evaluated exactly once.
TEST_F(SingleEvaluationTest, ExceptionTests) {
@ -3375,17 +3373,23 @@ TEST_F(SingleEvaluationTest, ExceptionTests) {
EXPECT_EQ(7, a_);
// failed EXPECT_THROW std::exception, throws different
EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT
a_++;
ThrowAnInteger();
}, std::exception), "throws a different type");
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(
{ // NOLINT
a_++;
ThrowAnInteger();
},
std::exception),
"throws a different type");
EXPECT_EQ(8, a_);
// failed EXPECT_THROW, throws std::exception
EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT
a_++;
ThrowAnException("blablubb");
}, bool), "throws a different type with message: blablubb");
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(
{ // NOLINT
a_++;
ThrowAnException("blablubb");
},
bool),
"throws a different type with message: blablubb");
EXPECT_EQ(9, a_);
}
@ -4566,10 +4570,10 @@ TEST(ExpectTest, EXPECT_THROW) {
"Expected: ThrowAnInteger() throws an exception of "
"type bool.\n Actual: it throws a different type.");
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowNothing(), bool),
"Expected: ThrowNothing() throws an exception of "
"Expected: ThrowNothing() throws an exception of "
"type bool.\n Actual: it throws nothing.");
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnException("buuh"), bool),
"Expected: ThrowAnException(\"buuh\") throws an "
"Expected: ThrowAnException(\"buuh\") throws an "
"exception of type bool.\n Actual: "
"it throws a different type with message: buuh");
}
@ -5531,7 +5535,7 @@ struct Flags {
// Factory methods.
// Creates a Flags struct where the gtest_also_run_disabled_tests flag has
// Creates a Flags struct where the gunit_also_run_disabled_tests flag has
// the given value.
static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
Flags flags;
@ -5539,7 +5543,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_break_on_failure flag has
// Creates a Flags struct where the gunit_break_on_failure flag has
// the given value.
static Flags BreakOnFailure(bool break_on_failure) {
Flags flags;
@ -5547,7 +5551,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_catch_exceptions flag has
// Creates a Flags struct where the gunit_catch_exceptions flag has
// the given value.
static Flags CatchExceptions(bool catch_exceptions) {
Flags flags;
@ -5555,7 +5559,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_death_test_use_fork flag has
// Creates a Flags struct where the gunit_death_test_use_fork flag has
// the given value.
static Flags DeathTestUseFork(bool death_test_use_fork) {
Flags flags;
@ -5563,7 +5567,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_filter flag has the given
// Creates a Flags struct where the gunit_filter flag has the given
// value.
static Flags Filter(const char* filter) {
Flags flags;
@ -5571,7 +5575,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_list_tests flag has the
// Creates a Flags struct where the gunit_list_tests flag has the
// given value.
static Flags ListTests(bool list_tests) {
Flags flags;
@ -5579,7 +5583,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_output flag has the given
// Creates a Flags struct where the gunit_output flag has the given
// value.
static Flags Output(const char* output) {
Flags flags;
@ -5587,7 +5591,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_print_time flag has the given
// Creates a Flags struct where the gunit_print_time flag has the given
// value.
static Flags PrintTime(bool print_time) {
Flags flags;
@ -5595,7 +5599,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_random_seed flag has the given
// Creates a Flags struct where the gunit_random_seed flag has the given
// value.
static Flags RandomSeed(Int32 random_seed) {
Flags flags;
@ -5603,7 +5607,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_repeat flag has the given
// Creates a Flags struct where the gunit_repeat flag has the given
// value.
static Flags Repeat(Int32 repeat) {
Flags flags;
@ -5611,7 +5615,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_shuffle flag has the given
// Creates a Flags struct where the gunit_shuffle flag has the given
// value.
static Flags Shuffle(bool shuffle) {
Flags flags;
@ -5635,7 +5639,7 @@ struct Flags {
return flags;
}
// Creates a Flags struct where the gtest_throw_on_failure flag has
// Creates a Flags struct where the gunit_throw_on_failure flag has
// the given value.
static Flags ThrowOnFailure(bool throw_on_failure) {
Flags flags;
@ -5795,28 +5799,28 @@ TEST_F(ParseFlagsTest, NoFlag) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
}
// Tests parsing a bad --gtest_filter flag.
// Tests parsing a bad --gunit_filter flag.
TEST_F(ParseFlagsTest, FilterBad) {
const char* argv[] = {
"foo.exe",
"--gtest_filter",
"--gunit_filter",
NULL
};
const char* argv2[] = {
"foo.exe",
"--gtest_filter",
"--gunit_filter",
NULL
};
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
}
// Tests parsing an empty --gtest_filter flag.
// Tests parsing an empty --gunit_filter flag.
TEST_F(ParseFlagsTest, FilterEmpty) {
const char* argv[] = {
"foo.exe",
"--gtest_filter=",
"--gunit_filter=",
NULL
};
@ -5828,11 +5832,11 @@ TEST_F(ParseFlagsTest, FilterEmpty) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false);
}
// Tests parsing a non-empty --gtest_filter flag.
// Tests parsing a non-empty --gunit_filter flag.
TEST_F(ParseFlagsTest, FilterNonEmpty) {
const char* argv[] = {
"foo.exe",
"--gtest_filter=abc",
"--gunit_filter=abc",
NULL
};
@ -5844,11 +5848,11 @@ TEST_F(ParseFlagsTest, FilterNonEmpty) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
}
// Tests parsing --gtest_break_on_failure.
// Tests parsing --gunit_break_on_failure.
TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure",
"--gunit_break_on_failure",
NULL
};
@ -5860,11 +5864,11 @@ TEST_F(ParseFlagsTest, BreakOnFailureWithoutValue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
}
// Tests parsing --gtest_break_on_failure=0.
// Tests parsing --gunit_break_on_failure=0.
TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure=0",
"--gunit_break_on_failure=0",
NULL
};
@ -5876,11 +5880,11 @@ TEST_F(ParseFlagsTest, BreakOnFailureFalse_0) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
}
// Tests parsing --gtest_break_on_failure=f.
// Tests parsing --gunit_break_on_failure=f.
TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure=f",
"--gunit_break_on_failure=f",
NULL
};
@ -5892,11 +5896,11 @@ TEST_F(ParseFlagsTest, BreakOnFailureFalse_f) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
}
// Tests parsing --gtest_break_on_failure=F.
// Tests parsing --gunit_break_on_failure=F.
TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure=F",
"--gunit_break_on_failure=F",
NULL
};
@ -5908,12 +5912,12 @@ TEST_F(ParseFlagsTest, BreakOnFailureFalse_F) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
}
// Tests parsing a --gtest_break_on_failure flag that has a "true"
// Tests parsing a --gunit_break_on_failure flag that has a "true"
// definition.
TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure=1",
"--gunit_break_on_failure=1",
NULL
};
@ -5925,11 +5929,11 @@ TEST_F(ParseFlagsTest, BreakOnFailureTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
}
// Tests parsing --gtest_catch_exceptions.
// Tests parsing --gunit_catch_exceptions.
TEST_F(ParseFlagsTest, CatchExceptions) {
const char* argv[] = {
"foo.exe",
"--gtest_catch_exceptions",
"--gunit_catch_exceptions",
NULL
};
@ -5941,11 +5945,11 @@ TEST_F(ParseFlagsTest, CatchExceptions) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false);
}
// Tests parsing --gtest_death_test_use_fork.
// Tests parsing --gunit_death_test_use_fork.
TEST_F(ParseFlagsTest, DeathTestUseFork) {
const char* argv[] = {
"foo.exe",
"--gtest_death_test_use_fork",
"--gunit_death_test_use_fork",
NULL
};
@ -5962,8 +5966,8 @@ TEST_F(ParseFlagsTest, DeathTestUseFork) {
TEST_F(ParseFlagsTest, DuplicatedFlags) {
const char* argv[] = {
"foo.exe",
"--gtest_filter=a",
"--gtest_filter=b",
"--gunit_filter=a",
"--gunit_filter=b",
NULL
};
@ -5979,9 +5983,9 @@ TEST_F(ParseFlagsTest, DuplicatedFlags) {
TEST_F(ParseFlagsTest, UnrecognizedFlag) {
const char* argv[] = {
"foo.exe",
"--gtest_break_on_failure",
"--gunit_break_on_failure",
"bar", // Unrecognized by Google Test.
"--gtest_filter=b",
"--gunit_filter=b",
NULL
};
@ -5997,11 +6001,11 @@ TEST_F(ParseFlagsTest, UnrecognizedFlag) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false);
}
// Tests having a --gtest_list_tests flag
// Tests having a --gunit_list_tests flag
TEST_F(ParseFlagsTest, ListTestsFlag) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests",
"--gunit_list_tests",
NULL
};
@ -6013,11 +6017,11 @@ TEST_F(ParseFlagsTest, ListTestsFlag) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
}
// Tests having a --gtest_list_tests flag with a "true" value
// Tests having a --gunit_list_tests flag with a "true" value
TEST_F(ParseFlagsTest, ListTestsTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests=1",
"--gunit_list_tests=1",
NULL
};
@ -6029,11 +6033,11 @@ TEST_F(ParseFlagsTest, ListTestsTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
}
// Tests having a --gtest_list_tests flag with a "false" value
// Tests having a --gunit_list_tests flag with a "false" value
TEST_F(ParseFlagsTest, ListTestsFalse) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests=0",
"--gunit_list_tests=0",
NULL
};
@ -6045,11 +6049,11 @@ TEST_F(ParseFlagsTest, ListTestsFalse) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
}
// Tests parsing --gtest_list_tests=f.
// Tests parsing --gunit_list_tests=f.
TEST_F(ParseFlagsTest, ListTestsFalse_f) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests=f",
"--gunit_list_tests=f",
NULL
};
@ -6061,11 +6065,11 @@ TEST_F(ParseFlagsTest, ListTestsFalse_f) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
}
// Tests parsing --gtest_list_tests=F.
// Tests parsing --gunit_list_tests=F.
TEST_F(ParseFlagsTest, ListTestsFalse_F) {
const char* argv[] = {
"foo.exe",
"--gtest_list_tests=F",
"--gunit_list_tests=F",
NULL
};
@ -6077,28 +6081,28 @@ TEST_F(ParseFlagsTest, ListTestsFalse_F) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
}
// Tests parsing --gtest_output (invalid).
// Tests parsing --gunit_output (invalid).
TEST_F(ParseFlagsTest, OutputEmpty) {
const char* argv[] = {
"foo.exe",
"--gtest_output",
"--gunit_output",
NULL
};
const char* argv2[] = {
"foo.exe",
"--gtest_output",
"--gunit_output",
NULL
};
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
}
// Tests parsing --gtest_output=xml
// Tests parsing --gunit_output=xml
TEST_F(ParseFlagsTest, OutputXml) {
const char* argv[] = {
"foo.exe",
"--gtest_output=xml",
"--gunit_output=xml",
NULL
};
@ -6110,11 +6114,11 @@ TEST_F(ParseFlagsTest, OutputXml) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false);
}
// Tests parsing --gtest_output=xml:file
// Tests parsing --gunit_output=xml:file
TEST_F(ParseFlagsTest, OutputXmlFile) {
const char* argv[] = {
"foo.exe",
"--gtest_output=xml:file",
"--gunit_output=xml:file",
NULL
};
@ -6126,11 +6130,11 @@ TEST_F(ParseFlagsTest, OutputXmlFile) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false);
}
// Tests parsing --gtest_output=xml:directory/path/
// Tests parsing --gunit_output=xml:directory/path/
TEST_F(ParseFlagsTest, OutputXmlDirectory) {
const char* argv[] = {
"foo.exe",
"--gtest_output=xml:directory/path/",
"--gunit_output=xml:directory/path/",
NULL
};
@ -6143,11 +6147,11 @@ TEST_F(ParseFlagsTest, OutputXmlDirectory) {
Flags::Output("xml:directory/path/"), false);
}
// Tests having a --gtest_print_time flag
// Tests having a --gunit_print_time flag
TEST_F(ParseFlagsTest, PrintTimeFlag) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time",
"--gunit_print_time",
NULL
};
@ -6159,11 +6163,11 @@ TEST_F(ParseFlagsTest, PrintTimeFlag) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
}
// Tests having a --gtest_print_time flag with a "true" value
// Tests having a --gunit_print_time flag with a "true" value
TEST_F(ParseFlagsTest, PrintTimeTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time=1",
"--gunit_print_time=1",
NULL
};
@ -6175,11 +6179,11 @@ TEST_F(ParseFlagsTest, PrintTimeTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
}
// Tests having a --gtest_print_time flag with a "false" value
// Tests having a --gunit_print_time flag with a "false" value
TEST_F(ParseFlagsTest, PrintTimeFalse) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time=0",
"--gunit_print_time=0",
NULL
};
@ -6191,11 +6195,11 @@ TEST_F(ParseFlagsTest, PrintTimeFalse) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
}
// Tests parsing --gtest_print_time=f.
// Tests parsing --gunit_print_time=f.
TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time=f",
"--gunit_print_time=f",
NULL
};
@ -6207,11 +6211,11 @@ TEST_F(ParseFlagsTest, PrintTimeFalse_f) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
}
// Tests parsing --gtest_print_time=F.
// Tests parsing --gunit_print_time=F.
TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
const char* argv[] = {
"foo.exe",
"--gtest_print_time=F",
"--gunit_print_time=F",
NULL
};
@ -6223,11 +6227,11 @@ TEST_F(ParseFlagsTest, PrintTimeFalse_F) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
}
// Tests parsing --gtest_random_seed=number
// Tests parsing --gunit_random_seed=number
TEST_F(ParseFlagsTest, RandomSeed) {
const char* argv[] = {
"foo.exe",
"--gtest_random_seed=1000",
"--gunit_random_seed=1000",
NULL
};
@ -6239,11 +6243,11 @@ TEST_F(ParseFlagsTest, RandomSeed) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false);
}
// Tests parsing --gtest_repeat=number
// Tests parsing --gunit_repeat=number
TEST_F(ParseFlagsTest, Repeat) {
const char* argv[] = {
"foo.exe",
"--gtest_repeat=1000",
"--gunit_repeat=1000",
NULL
};
@ -6255,11 +6259,11 @@ TEST_F(ParseFlagsTest, Repeat) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false);
}
// Tests having a --gtest_also_run_disabled_tests flag
// Tests having a --gunit_also_run_disabled_tests flag
TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
const char* argv[] = {
"foo.exe",
"--gtest_also_run_disabled_tests",
"--gunit_also_run_disabled_tests",
NULL
};
@ -6272,11 +6276,11 @@ TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFlag) {
Flags::AlsoRunDisabledTests(true), false);
}
// Tests having a --gtest_also_run_disabled_tests flag with a "true" value
// Tests having a --gunit_also_run_disabled_tests flag with a "true" value
TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_also_run_disabled_tests=1",
"--gunit_also_run_disabled_tests=1",
NULL
};
@ -6289,11 +6293,11 @@ TEST_F(ParseFlagsTest, AlsoRunDisabledTestsTrue) {
Flags::AlsoRunDisabledTests(true), false);
}
// Tests having a --gtest_also_run_disabled_tests flag with a "false" value
// Tests having a --gunit_also_run_disabled_tests flag with a "false" value
TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
const char* argv[] = {
"foo.exe",
"--gtest_also_run_disabled_tests=0",
"--gunit_also_run_disabled_tests=0",
NULL
};
@ -6306,11 +6310,11 @@ TEST_F(ParseFlagsTest, AlsoRunDisabledTestsFalse) {
Flags::AlsoRunDisabledTests(false), false);
}
// Tests parsing --gtest_shuffle.
// Tests parsing --gunit_shuffle.
TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
const char* argv[] = {
"foo.exe",
"--gtest_shuffle",
"--gunit_shuffle",
NULL
};
@ -6322,11 +6326,11 @@ TEST_F(ParseFlagsTest, ShuffleWithoutValue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
}
// Tests parsing --gtest_shuffle=0.
// Tests parsing --gunit_shuffle=0.
TEST_F(ParseFlagsTest, ShuffleFalse_0) {
const char* argv[] = {
"foo.exe",
"--gtest_shuffle=0",
"--gunit_shuffle=0",
NULL
};
@ -6338,11 +6342,11 @@ TEST_F(ParseFlagsTest, ShuffleFalse_0) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false);
}
// Tests parsing a --gtest_shuffle flag that has a "true" definition.
// Tests parsing a --gunit_shuffle flag that has a "true" definition.
TEST_F(ParseFlagsTest, ShuffleTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_shuffle=1",
"--gunit_shuffle=1",
NULL
};
@ -6354,11 +6358,11 @@ TEST_F(ParseFlagsTest, ShuffleTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
}
// Tests parsing --gtest_stack_trace_depth=number.
// Tests parsing --gunit_stack_trace_depth=number.
TEST_F(ParseFlagsTest, StackTraceDepth) {
const char* argv[] = {
"foo.exe",
"--gtest_stack_trace_depth=5",
"--gunit_stack_trace_depth=5",
NULL
};
@ -6373,7 +6377,7 @@ TEST_F(ParseFlagsTest, StackTraceDepth) {
TEST_F(ParseFlagsTest, StreamResultTo) {
const char* argv[] = {
"foo.exe",
"--gtest_stream_result_to=localhost:1234",
"--gunit_stream_result_to=localhost:1234",
NULL
};
@ -6386,11 +6390,11 @@ TEST_F(ParseFlagsTest, StreamResultTo) {
argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
}
// Tests parsing --gtest_throw_on_failure.
// Tests parsing --gunit_throw_on_failure.
TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
const char* argv[] = {
"foo.exe",
"--gtest_throw_on_failure",
"--gunit_throw_on_failure",
NULL
};
@ -6402,11 +6406,11 @@ TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
}
// Tests parsing --gtest_throw_on_failure=0.
// Tests parsing --gunit_throw_on_failure=0.
TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
const char* argv[] = {
"foo.exe",
"--gtest_throw_on_failure=0",
"--gunit_throw_on_failure=0",
NULL
};
@ -6418,12 +6422,12 @@ TEST_F(ParseFlagsTest, ThrowOnFailureFalse_0) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false);
}
// Tests parsing a --gtest_throw_on_failure flag that has a "true"
// Tests parsing a --gunit_throw_on_failure flag that has a "true"
// definition.
TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
const char* argv[] = {
"foo.exe",
"--gtest_throw_on_failure=1",
"--gunit_throw_on_failure=1",
NULL
};
@ -6440,16 +6444,16 @@ TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
TEST_F(ParseFlagsTest, WideStrings) {
const wchar_t* argv[] = {
L"foo.exe",
L"--gtest_filter=Foo*",
L"--gtest_list_tests=1",
L"--gtest_break_on_failure",
L"--non_gtest_flag",
L"--gunit_filter=Foo*",
L"--gunit_list_tests=1",
L"--gunit_break_on_failure",
L"--non_gunit_flag",
NULL
};
const wchar_t* argv2[] = {
L"foo.exe",
L"--non_gtest_flag",
L"--non_gunit_flag",
NULL
};
@ -6513,7 +6517,7 @@ TEST_F(FlagfileTest, Empty) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
}
// Tests passing a non-empty --gtest_filter flag via --gtest_flagfile.
// Tests passing a non-empty --gunit_filter flag via --gunit_flagfile.
TEST_F(FlagfileTest, FilterNonEmpty) {
internal::FilePath flagfile_path(CreateFlagfile(
"--" GTEST_FLAG_PREFIX_ "filter=abc"));
@ -6534,7 +6538,7 @@ TEST_F(FlagfileTest, FilterNonEmpty) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
}
// Tests passing several flags via --gtest_flagfile.
// Tests passing several flags via --gunit_flagfile.
TEST_F(FlagfileTest, SeveralFlags) {
internal::FilePath flagfile_path(CreateFlagfile(
"--" GTEST_FLAG_PREFIX_ "filter=abc\n"