gtest.cc File Reference

#include "gtest/gtest.h"
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <wchar.h>
#include <wctype.h>
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <initializer_list>
#include <iomanip>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <ostream>
#include <sstream>
#include <unordered_set>
#include <vector>
#include "gtest/gtest-assertion-result.h"
#include "gtest/gtest-spi.h"
#include "gtest/internal/custom/gtest.h"
#include <sys/time.h>
#include <unistd.h>
#include "src/gtest-internal-inl.h"

Go to the source code of this file.

Classes
class	testing::internal::Timer
class	testing::internal::PrettyUnitTestResultPrinter
class	testing::internal::BriefUnitTestResultPrinter
class	testing::internal::TestEventRepeater
class	testing::internal::XmlUnitTestResultPrinter
class	testing::internal::JsonUnitTestResultPrinter
class	testing::internal::ScopedPrematureExitFile
class	testing::internal::TestSuiteNameIs

Namespaces
namespace	testing
namespace	testing::internal
namespace	testing::internal::edit_distance

Macros
#define	GTEST_REPEATER_METHOD_(Name, Type)
#define	GTEST_REVERSE_REPEATER_METHOD_(Name, Type)
#define	GTEST_INTERNAL_PARSE_FLAG(flag_name)

Functions
static FILE *	testing::internal::OpenFileForWriting (const std::string &output_file)
static const char *	testing::GetDefaultFilter ()
static bool	testing::GetDefaultFailFast ()
	GTEST_DEFINE_bool_ (fail_fast, testing::internal::BoolFromGTestEnv("fail_fast", testing::GetDefaultFailFast()), "True if and only if a test failure should stop further test execution.")
	GTEST_DEFINE_bool_ (also_run_disabled_tests, testing::internal::BoolFromGTestEnv("also_run_disabled_tests", false), "Run disabled tests too, in addition to the tests normally being run.")
	GTEST_DEFINE_bool_ (break_on_failure, testing::internal::BoolFromGTestEnv("break_on_failure", false), "True if and only if a failed assertion should be a debugger " "break-point.")
	GTEST_DEFINE_bool_ (catch_exceptions, testing::internal::BoolFromGTestEnv("catch_exceptions", true), "True if and only if " GTEST_NAME_ " should catch exceptions and treat them as test failures.")
	GTEST_DEFINE_string_ (color, testing::internal::StringFromGTestEnv("color", "auto"), "Whether to use colors in the output. Valid values: yes, no, " "and auto. 'auto' means to use colors if the output is " "being sent to a terminal and the TERM environment variable " "is set to a terminal type that supports colors.")
	GTEST_DEFINE_string_ (filter, testing::internal::StringFromGTestEnv("filter", testing::GetDefaultFilter()), "A colon-separated list of glob (not regex) patterns " "for filtering the tests to run, optionally followed by a " "'-' and a : separated list of negative patterns (tests to " "exclude). A test is run if it matches one of the positive " "patterns and does not match any of the negative patterns.")
	GTEST_DEFINE_bool_ (install_failure_signal_handler, testing::internal::BoolFromGTestEnv("install_failure_signal_handler", false), "If true and supported on the current platform, " GTEST_NAME_ " should " "install a signal handler that dumps debugging information when fatal " "signals are raised.")
	GTEST_DEFINE_bool_ (list_tests, false, "List all tests without running them.")
	GTEST_DEFINE_string_ (output, testing::internal::StringFromGTestEnv("output", testing::internal::OutputFlagAlsoCheckEnvVar().c_str()), "A format (defaults to \"xml\" but can be specified to be \"json\"), " "optionally followed by a colon and an output file name or directory. " "A directory is indicated by a trailing pathname separator. " "Examples: \"xml:filename.xml\", \"xml::directoryname/\". " "If a directory is specified, output files will be created " "within that directory, with file-names based on the test " "executable's name and, if necessary, made unique by adding " "digits.")
	GTEST_DEFINE_bool_ (brief, testing::internal::BoolFromGTestEnv("brief", false), "True if only test failures should be displayed in text output.")
	GTEST_DEFINE_bool_ (print_time, testing::internal::BoolFromGTestEnv("print_time", true), "True if and only if " GTEST_NAME_ " should display elapsed time in text output.")
	GTEST_DEFINE_bool_ (print_utf8, testing::internal::BoolFromGTestEnv("print_utf8", true), "True if and only if " GTEST_NAME_ " prints UTF8 characters as text.")
	GTEST_DEFINE_int32_ (random_seed, testing::internal::Int32FromGTestEnv("random_seed", 0), "Random number seed to use when shuffling test orders. Must be in range " "[1, 99999], or 0 to use a seed based on the current time.")
	GTEST_DEFINE_int32_ (repeat, testing::internal::Int32FromGTestEnv("repeat", 1), "How many times to repeat each test. Specify a negative number " "for repeating forever. Useful for shaking out flaky tests.")
	GTEST_DEFINE_bool_ (recreate_environments_when_repeating, testing::internal::BoolFromGTestEnv("recreate_environments_when_repeating", false), "Controls whether global test environments are recreated for each repeat " "of the tests. If set to false the global test environments are only set " "up once, for the first iteration, and only torn down once, for the last. " "Useful for shaking out flaky tests with stable, expensive test " "environments. If --gtest_repeat is set to a negative number, meaning " "there is no last run, the environments will always be recreated to avoid " "leaks.")
	GTEST_DEFINE_bool_ (show_internal_stack_frames, false, "True if and only if " GTEST_NAME_ " should include internal stack frames when " "printing test failure stack traces.")
	GTEST_DEFINE_bool_ (shuffle, testing::internal::BoolFromGTestEnv("shuffle", false), "True if and only if " GTEST_NAME_ " should randomize tests' order on every run.")
	GTEST_DEFINE_int32_ (stack_trace_depth, testing::internal::Int32FromGTestEnv("stack_trace_depth", testing::kMaxStackTraceDepth), "The maximum number of stack frames to print when an " "assertion fails. The valid range is 0 through 100, inclusive.")
	GTEST_DEFINE_string_ (stream_result_to, testing::internal::StringFromGTestEnv("stream_result_to", ""), "This flag specifies the host name and the port number on which to stream " "test results. Example: \"localhost:555\". The flag is effective only on " "Linux.")
	GTEST_DEFINE_bool_ (throw_on_failure, testing::internal::BoolFromGTestEnv("throw_on_failure", false), "When this flag is specified, a failed assertion will throw an exception " "if exceptions are enabled or exit the program with a non-zero code " "otherwise. For use with an external test framework.")
static bool	testing::internal::GTestIsInitialized ()
static int	testing::internal::SumOverTestSuiteList (const std::vector< TestSuite * > &case_list, int(TestSuite::*method)() const)
static bool	testing::internal::TestSuitePassed (const TestSuite *test_suite)
static bool	testing::internal::TestSuiteFailed (const TestSuite *test_suite)
static bool	testing::internal::ShouldRunTestSuite (const TestSuite *test_suite)
std::set< std::string > *	testing::internal::GetIgnoredParameterizedTestSuites ()
void	testing::internal::InsertSyntheticTestCase (const std::string &name, CodeLocation location, bool has_test_p)
void	testing::internal::RegisterTypeParameterizedTestSuite (const char *test_suite_name, CodeLocation code_location)
void	testing::internal::RegisterTypeParameterizedTestSuiteInstantiation (const char *case_name)
::std::vector< std::string >	testing::internal::GetArgvs ()
GTEST_API_ FilePath	testing::internal::GetCurrentExecutableName ()
static bool	testing::internal::PatternMatchesString (const std::string &name_str, const char *pattern, const char *pattern_end)
TypeId	testing::internal::GetTestTypeId ()
static AssertionResult	testing::internal::HasOneFailure (const char *, const char *, const char *, const TestPartResultArray &results, TestPartResult::Type type, const std::string &substr)
GTEST_API_ TimeInMillis	testing::internal::GetTimeInMillis ()
void	testing::internal::SplitString (const ::std::string &str, char delimiter, ::std::vector< ::std::string > *dest)
std::vector< EditType >	testing::internal::edit_distance::CalculateOptimalEdits (const std::vector< size_t > &left, const std::vector< size_t > &right)
std::vector< EditType >	testing::internal::edit_distance::CalculateOptimalEdits (const std::vector< std::string > &left, const std::vector< std::string > &right)
std::string	testing::internal::edit_distance::CreateUnifiedDiff (const std::vector< std::string > &left, const std::vector< std::string > &right, size_t context)
AssertionResult	testing::internal::EqFailure (const char *lhs_expression, const char *rhs_expression, const std::string &lhs_value, const std::string &rhs_value, bool ignoring_case)
std::string	testing::internal::GetBoolAssertionFailureMessage (const AssertionResult &assertion_result, const char *expression_text, const char *actual_predicate_value, const char *expected_predicate_value)
AssertionResult	testing::internal::DoubleNearPredFormat (const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
template<typename RawType >
AssertionResult	testing::internal::FloatingPointLE (const char *expr1, const char *expr2, RawType val1, RawType val2)
AssertionResult	testing::FloatLE (const char *expr1, const char *expr2, float val1, float val2)
AssertionResult	testing::DoubleLE (const char *expr1, const char *expr2, double val1, double val2)
AssertionResult	testing::internal::CmpHelperSTREQ (const char *lhs_expression, const char *rhs_expression, const char *lhs, const char *rhs)
AssertionResult	testing::internal::CmpHelperSTRCASEEQ (const char *lhs_expression, const char *rhs_expression, const char *lhs, const char *rhs)
AssertionResult	testing::internal::CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
AssertionResult	testing::internal::CmpHelperSTRCASENE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
uint32_t	testing::internal::ChopLowBits (uint32_t *bits, int n)
GTEST_API_ std::string	testing::internal::CodePointToUtf8 (uint32_t code_point)
bool	testing::internal::IsUtf16SurrogatePair (wchar_t first, wchar_t second)
uint32_t	testing::internal::CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)
GTEST_API_ std::string	testing::internal::WideStringToUtf8 (const wchar_t *str, int num_chars)
AssertionResult	testing::internal::CmpHelperSTREQ (const char *lhs_expression, const char *rhs_expression, const wchar_t *lhs, const wchar_t *rhs)
AssertionResult	testing::internal::CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
std::string	testing::internal::StringStreamToString (::std::stringstream *ss)
std::string	testing::internal::AppendUserMessage (const std::string &gtest_msg, const Message &user_msg)
template<size_t kSize>
std::vector< std::string >	testing::ArrayAsVector (const char *const (&array)[kSize])
static std::vector< std::string >	testing::GetReservedAttributesForElement (const std::string &xml_element)
static std::vector< std::string >	testing::GetReservedOutputAttributesForElement (const std::string &xml_element)
static std::string	testing::FormatWordList (const std::vector< std::string > &words)
static bool	testing::ValidateTestPropertyName (const std::string &property_name, const std::vector< std::string > &reserved_names)
static bool	testing::TestPartSkipped (const TestPartResult &result)
static bool	testing::TestPartFatallyFailed (const TestPartResult &result)
static bool	testing::TestPartNonfatallyFailed (const TestPartResult &result)
void	testing::internal::ReportFailureInUnknownLocation (TestPartResult::Type result_type, const std::string &message)
template<class T , typename Result >
Result	testing::internal::HandleSehExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
template<class T , typename Result >
Result	testing::internal::HandleExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
TestInfo *	testing::internal::MakeAndRegisterTestInfo (const char *test_suite_name, const char *name, const char *type_param, const char *value_param, CodeLocation code_location, TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc, TearDownTestSuiteFunc tear_down_tc, TestFactoryBase *factory)
void	testing::internal::ReportInvalidTestSuiteType (const char *test_suite_name, CodeLocation code_location)
static std::string	testing::FormatCountableNoun (int count, const char *singular_form, const char *plural_form)
static std::string	testing::FormatTestCount (int test_count)
static std::string	testing::FormatTestSuiteCount (int test_suite_count)
static const char *	testing::TestPartResultTypeToString (TestPartResult::Type type)
static std::string	testing::internal::PrintTestPartResultToString (const TestPartResult &test_part_result)
static void	testing::internal::PrintTestPartResult (const TestPartResult &test_part_result)
static const char *	testing::internal::GetAnsiColorCode (GTestColor color)
GTEST_API_ bool	testing::internal::ShouldUseColor (bool stdout_is_tty)
static void	testing::internal::ColoredPrintf (GTestColor color, const char *fmt,...)
static void	testing::internal::PrintFullTestCommentIfPresent (const TestInfo &test_info)
GTEST_API_ std::string	testing::internal::FormatTimeInMillisAsSeconds (TimeInMillis ms)
static bool	testing::internal::PortableLocaltime (time_t seconds, struct tm *out)
GTEST_API_ std::string	testing::internal::FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)
static std::string	testing::internal::FormatTimeInMillisAsDuration (TimeInMillis ms)
static std::string	testing::internal::FormatEpochTimeInMillisAsRFC3339 (TimeInMillis ms)
static std::string	testing::internal::Indent (size_t width)
static void	testing::internal::SetUpEnvironment (Environment *env)
static void	testing::internal::TearDownEnvironment (Environment *env)
void	testing::internal::WriteToShardStatusFileIfNeeded ()
GTEST_API_ bool	testing::internal::ShouldShard (const char *total_shards_str, const char *shard_index_str, bool in_subprocess_for_death_test)
GTEST_API_ int32_t	testing::internal::Int32FromEnvOrDie (const char *env_var, int32_t default_val)
GTEST_API_ bool	testing::internal::ShouldRunTestOnShard (int total_shards, int shard_index, int test_id)
static void	testing::internal::PrintOnOneLine (const char *str, int max_length)
GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string	testing::internal::GetCurrentOsStackTraceExceptTop (UnitTest *, int skip_count)
bool	testing::internal::IsTrue (bool condition)
bool	testing::internal::AlwaysTrue ()
bool	testing::internal::SkipPrefix (const char *prefix, const char **pstr)
static const char *	testing::internal::ParseFlagValue (const char *str, const char *flag_name, bool def_optional)
static bool	testing::internal::ParseFlag (const char *str, const char *flag_name, bool *value)
GTEST_API_ bool	testing::internal::ParseFlag (const char *str, const char *flag, int32_t *value)
template<typename String >
static bool	testing::internal::ParseFlag (const char *str, const char *flag_name, String *value)
static bool	testing::internal::HasGoogleTestFlagPrefix (const char *str)
static void	testing::internal::PrintColorEncoded (const char *str)
static bool	testing::internal::ParseGoogleTestFlag (const char *const arg)
template<typename CharType >
void	testing::internal::ParseGoogleTestFlagsOnlyImpl (int *argc, CharType **argv)
GTEST_API_ void	testing::internal::ParseGoogleTestFlagsOnly (int *argc, char **argv)
GTEST_API_ void	testing::internal::ParseGoogleTestFlagsOnly (int *argc, wchar_t **argv)
template<typename CharType >
void	testing::internal::InitGoogleTestImpl (int *argc, CharType **argv)
void	testing::InitGoogleTest (int *argc, char **argv)
void	testing::InitGoogleTest (int *argc, wchar_t **argv)
void	testing::InitGoogleTest ()
static std::string	testing::GetTempDirFromEnv (std::initializer_list< const char * > environment_variables, const char *fallback, char separator)
std::string	testing::TempDir ()

Variables
static const char	testing::kDisableTestFilter [] = "DISABLED_*:*/DISABLED_*"
static const char	testing::kDeathTestSuiteFilter [] = "*DeathTest:*DeathTest/*"
static const char	testing::kUniversalFilter [] = "*"
static const char	testing::kDefaultOutputFormat [] = "xml"
static const char	testing::kDefaultOutputFile [] = "test_detail"
static const char	testing::kTestShardIndex [] = "GTEST_SHARD_INDEX"
static const char	testing::kTestTotalShards [] = "GTEST_TOTAL_SHARDS"
static const char	testing::kTestShardStatusFile [] = "GTEST_SHARD_STATUS_FILE"
const char	testing::internal::kStackTraceMarker [] = "\nStack trace:\n"
static ::std::vector< std::string >	testing::internal::g_argvs
constexpr uint32_t	testing::internal::kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1
constexpr uint32_t	testing::internal::kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1
constexpr uint32_t	testing::internal::kMaxCodePoint3
constexpr uint32_t	testing::internal::kMaxCodePoint4
static const char *const	testing::kReservedTestSuitesAttributes []
static const char *const	testing::kReservedTestSuiteAttributes []
static const char *const	testing::kReservedTestCaseAttributes []
static const char *const	testing::kReservedOutputTestCaseAttributes []
static const char	testing::internal::kTypeParamLabel [] = "TypeParam"
static const char	testing::internal::kValueParamLabel [] = "GetParam()"
static const char	testing::internal::kColorEncodedHelpMessage []

Macro Definition Documentation

GTEST_INTERNAL_PARSE_FLAG

#define GTEST_INTERNAL_PARSE_FLAG

(

flag_name

)

Value:

  do {                                        \
    auto value = GTEST_FLAG_GET(flag_name);   \
    if (ParseFlag(arg, #flag_name, &value)) { \
      GTEST_FLAG_SET(flag_name, value);       \
      return true;                            \
    }                                         \
  } while (false)

GTEST_REPEATER_METHOD_

#define GTEST_REPEATER_METHOD_	(		Name,
			Type )

Value:

  void TestEventRepeater::Name(const Type& parameter) { \
    if (forwarding_enabled_) {                          \
      for (size_t i = 0; i < listeners_.size(); i++) {  \
        listeners_[i]->Name(parameter);                 \
      }                                                 \
    }                                                   \
  }

Definition at line 3824 of file gtest.cc.

GTEST_REVERSE_REPEATER_METHOD_

#define GTEST_REVERSE_REPEATER_METHOD_	(		Name,
			Type )

Value:

  void TestEventRepeater::Name(const Type& parameter) { \
    if (forwarding_enabled_) {                          \
      for (size_t i = listeners_.size(); i != 0; i--) { \
        listeners_[i - 1]->Name(parameter);             \
      }                                                 \
    }                                                   \
  }

Definition at line 3834 of file gtest.cc.

Function Documentation

GTEST_DEFINE_bool_() [1/13]

GTEST_DEFINE_bool_	(	also_run_disabled_tests	,
		testing::internal::BoolFromGTestEnv("also_run_disabled_tests", false)	,
		"Run disabled tests	too,
		in addition to the tests normally being run."	)

GTEST_DEFINE_bool_() [2/13]

GTEST_DEFINE_bool_	(	break_on_failure	,
		testing::internal::BoolFromGTestEnv("break_on_failure", false)	,
		"True if and only if a failed assertion should be a debugger " "break-point."	)

GTEST_DEFINE_bool_() [3/13]

GTEST_DEFINE_bool_	(	brief	,
		testing::internal::BoolFromGTestEnv("brief", false)	,
		"True if only test failures should be displayed in text output."	)

GTEST_DEFINE_bool_() [4/13]

GTEST_DEFINE_bool_	(	catch_exceptions	,
		testing::internal::BoolFromGTestEnv("catch_exceptions", true)	,
		"True if and only if " GTEST_NAME_ " should catch exceptions and treat them as test failures."	)

GTEST_DEFINE_bool_() [5/13]

GTEST_DEFINE_bool_	(	fail_fast	,
		testing::internal::BoolFromGTestEnv("fail_fast", testing::GetDefaultFailFast())	,
		"True if and only if a test failure should stop further test execution."	)

GTEST_DEFINE_bool_() [6/13]

GTEST_DEFINE_bool_	(	install_failure_signal_handler	,
		testing::internal::BoolFromGTestEnv("install_failure_signal_handler", false)	,
		"If true and supported on the current	platform,
		" GTEST_NAME_ " should " "install a signal handler that dumps debugging information when fatal " "signals are raised."	)

GTEST_DEFINE_bool_() [7/13]

GTEST_DEFINE_bool_	(	list_tests	,
		false	,
		"List all tests without running them."	)

GTEST_DEFINE_bool_() [8/13]

GTEST_DEFINE_bool_	(	print_time	,
		testing::internal::BoolFromGTestEnv("print_time", true)	,
		"True if and only if " GTEST_NAME_ " should display elapsed time in text output."	)

GTEST_DEFINE_bool_() [9/13]

GTEST_DEFINE_bool_	(	print_utf8	,
		testing::internal::BoolFromGTestEnv("print_utf8", true)	,
		"True if and only if " GTEST_NAME_ " prints UTF8 characters as text."	)

GTEST_DEFINE_bool_() [10/13]

GTEST_DEFINE_bool_	(	recreate_environments_when_repeating	,
		testing::internal::BoolFromGTestEnv("recreate_environments_when_repeating", false)	,
		"Controls whether global test environments are recreated for each repeat " "of the tests. If set to false the global test environments are only set " "up	once,
		for the first	iteration,
		and only torn down	once,
		for the last. " "Useful for shaking out flaky tests with	stable,
		expensive test " "environments. If --gtest_repeat is set to a negative	number,
		meaning " "there is no last	run,
		the environments will always be recreated to avoid " "leaks."	)

GTEST_DEFINE_bool_() [11/13]

GTEST_DEFINE_bool_	(	show_internal_stack_frames	,
		false	,
		"True if and only if " GTEST_NAME_ " should include internal stack frames when " "printing test failure stack traces."	)

GTEST_DEFINE_bool_() [12/13]

GTEST_DEFINE_bool_	(	shuffle	,
		testing::internal::BoolFromGTestEnv("shuffle", false)	,
		"True if and only if " GTEST_NAME_ " should randomize tests' order on every run."	)

GTEST_DEFINE_bool_() [13/13]

GTEST_DEFINE_bool_	(	throw_on_failure	,
		testing::internal::BoolFromGTestEnv("throw_on_failure", false)	,
		"When this flag is	specified,
		a failed assertion will throw an exception " "if exceptions are enabled or exit the program with a non-zero code " "otherwise. For use with an external test framework."	)

GTEST_DEFINE_int32_() [1/3]

GTEST_DEFINE_int32_	(	random_seed	,
		testing::internal::Int32FromGTestEnv("random_seed", 0)	,
		"Random number seed to use when shuffling test orders. Must be in range " "	[1, 99999],
		or 0 to use a seed based on the current time."	)

GTEST_DEFINE_int32_() [2/3]

GTEST_DEFINE_int32_	(	repeat	,
		testing::internal::Int32FromGTestEnv("repeat", 1)	,
		"How many times to repeat each test. Specify a negative number " "for repeating forever. Useful for shaking out flaky tests."	)

GTEST_DEFINE_int32_() [3/3]

GTEST_DEFINE_int32_	(	stack_trace_depth	,
		testing::internal::Int32FromGTestEnv("stack_trace_depth", testing::kMaxStackTraceDepth)	,
		"The maximum number of stack frames to print when an " "assertion fails. The valid range is 0 through	100,
		inclusive."	)

GTEST_DEFINE_string_() [1/4]

GTEST_DEFINE_string_	(	color	,
		testing::internal::StringFromGTestEnv("color", "auto")	,
		"Whether to use colors in the output. Valid values:	yes,
		no	,
		" "and auto. 'auto' means to use colors if the output is " "being sent to a terminal and the TERM environment variable " "is set to a terminal type that supports colors."	)

GTEST_DEFINE_string_() [2/4]

GTEST_DEFINE_string_	(	filter	,
		testing::internal::StringFromGTestEnv("filter", testing::GetDefaultFilter())	,
		"A colon-separated list of glob (not regex) patterns " "for filtering the tests to	run,
		optionally followed by a " "'-' and a :separated list of negative patterns(tests to " "exclude). A test is run if it matches one of the positive " "patterns and does not match any of the negative patterns."	)

GTEST_DEFINE_string_() [3/4]

GTEST_DEFINE_string_	(	output	,
		testing::internal::StringFromGTestEnv("output", testing::internal::OutputFlagAlsoCheckEnvVar().c_str())	,
		"A format	defaults to \"xml\" but can be specified to be \"json\",
		" "optionally followed by a colon and an output file name or directory. " "A directory is indicated by a trailing pathname separator. " "Examples:\"xml:filename.xml\"	,
		\"xml::directoryname/\". " "If a directory is	specified,
		output files will be created " "within that	directory,
		with file-names based on the test " "executable 's name	and,
		if	necessary,
		made unique by adding " "digits."	)

GTEST_DEFINE_string_() [4/4]

GTEST_DEFINE_string_	(	stream_result_to	,
		testing::internal::StringFromGTestEnv("stream_result_to", "")	,
		"This flag specifies the host name and the port number on which to stream " "test results. Example: \"localhost:555\". The flag is effective only on " "Linux."	)