Chiebot-Mirror
/
googletest
mirror of https://github.com/google/googletest.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Formatting

Browse Source
pull/1850/head
Gennadiy Civil 7 years ago committed by GitHub
parent 78d3bfeb44
commit 5293383707
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 118 additions and 114 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 232
      googletest/test/gtest_unittest.cc

232
googletest/test/gtest_unittest.cc
Unescape 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"

Write Preview
Loading…
Cancel
Save