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 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
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. 202
      googletest/test/gtest_unittest.cc

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

Write Preview
Loading…
Cancel
Save