diff --git a/googletest/include/gtest/gtest.h b/googletest/include/gtest/gtest.h index 7be0caaf..4fe862b6 100644 --- a/googletest/include/gtest/gtest.h +++ b/googletest/include/gtest/gtest.h @@ -152,6 +152,10 @@ GTEST_DECLARE_int32_(stack_trace_depth); // non-zero code otherwise. For use with an external test framework. GTEST_DECLARE_bool_(throw_on_failure); +// When this flag is set, results are streamed to stdout +// without pretty-print formatting +GTEST_DECLARE_bool_(machine_results); + // When this flag is set with a "host:port" string, on supported // platforms test results are streamed to the specified port on // the specified host machine. diff --git a/googletest/src/gtest-internal-inl.h b/googletest/src/gtest-internal-inl.h index 6a39b93b..4d8c9a66 100644 --- a/googletest/src/gtest-internal-inl.h +++ b/googletest/src/gtest-internal-inl.h @@ -162,8 +162,9 @@ class GTestFlagSaver { GTEST_FLAG_GET(recreate_environments_when_repeating); shuffle_ = GTEST_FLAG_GET(shuffle); stack_trace_depth_ = GTEST_FLAG_GET(stack_trace_depth); - stream_result_to_ = GTEST_FLAG_GET(stream_result_to); throw_on_failure_ = GTEST_FLAG_GET(throw_on_failure); + machine_results_ = GTEST_FLAG_GET(machine_results); + stream_result_to_ = GTEST_FLAG_GET(stream_result_to); } // The d'tor is not virtual. DO NOT INHERIT FROM THIS CLASS. @@ -188,8 +189,9 @@ class GTestFlagSaver { recreate_environments_when_repeating_); GTEST_FLAG_SET(shuffle, shuffle_); GTEST_FLAG_SET(stack_trace_depth, stack_trace_depth_); - GTEST_FLAG_SET(stream_result_to, stream_result_to_); GTEST_FLAG_SET(throw_on_failure, throw_on_failure_); + GTEST_FLAG_SET(machine_results, machine_results_); + GTEST_FLAG_SET(stream_result_to, stream_result_to_); } private: @@ -213,8 +215,9 @@ class GTestFlagSaver { bool recreate_environments_when_repeating_; bool shuffle_; int32_t stack_trace_depth_; - std::string stream_result_to_; bool throw_on_failure_; + bool machine_results_; + std::string stream_result_to_; }; // Converts a Unicode code point to a narrow string in UTF-8 encoding. diff --git a/googletest/src/gtest.cc b/googletest/src/gtest.cc index 09af1517..31df9adc 100644 --- a/googletest/src/gtest.cc +++ b/googletest/src/gtest.cc @@ -385,13 +385,6 @@ GTEST_DEFINE_int32_( "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 and macOS."); - GTEST_DEFINE_bool_( throw_on_failure, testing::internal::BoolFromGTestEnv("throw_on_failure", false), @@ -399,6 +392,19 @@ GTEST_DEFINE_bool_( "if exceptions are enabled or exit the program with a non-zero code " "otherwise. For use with an external test framework."); +GTEST_DEFINE_bool_( + machine_results, + testing::internal::BoolFromGTestEnv("machine_results", false), + "When this flag is specified, results are streamed to stdout " + "without pretty-printing. Uses the same format as stream_result_to"); + +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 and macOS."); + #if GTEST_USE_OWN_FLAGFILE_FLAG_ GTEST_DEFINE_string_( flagfile, testing::internal::StringFromGTestEnv("flagfile", ""), @@ -5756,6 +5762,12 @@ void UnitTestImpl::ConfigureXmlOutput() { #endif // GTEST_HAS_FILE_SYSTEM } +#if GTEST_HAS_TERMINAL +void PrintToTerminal() { + // Unsure of whether to use listener system, or to try and print events directly to terminal +} +#endif // GTEST_HAS_TERMINAL + #if GTEST_CAN_STREAM_RESULTS_ // Initializes event listeners for streaming test results in string form. // Must not be called before InitGoogleTest. @@ -6775,8 +6787,9 @@ static bool ParseGoogleTestFlag(const char* const arg) { GTEST_INTERNAL_PARSE_FLAG(recreate_environments_when_repeating); GTEST_INTERNAL_PARSE_FLAG(shuffle); GTEST_INTERNAL_PARSE_FLAG(stack_trace_depth); - GTEST_INTERNAL_PARSE_FLAG(stream_result_to); GTEST_INTERNAL_PARSE_FLAG(throw_on_failure); + GTEST_INTERNAL_PARSE_FLAG(machine_results); + GTEST_INTERNAL_PARSE_FLAG(stream_result_to); return false; } diff --git a/googletest/test/gtest_unittest.cc b/googletest/test/gtest_unittest.cc index 559d34c0..3b568fc1 100644 --- a/googletest/test/gtest_unittest.cc +++ b/googletest/test/gtest_unittest.cc @@ -48,8 +48,9 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) { GTEST_FLAG_GET(recreate_environments_when_repeating) || GTEST_FLAG_GET(show_internal_stack_frames) || GTEST_FLAG_GET(shuffle) || GTEST_FLAG_GET(stack_trace_depth) > 0 || - GTEST_FLAG_GET(stream_result_to) != "unknown" || - GTEST_FLAG_GET(throw_on_failure); + GTEST_FLAG_GET(throw_on_failure) || + GTEST_FLAG_GET(machine_results) || + GTEST_FLAG_GET(stream_result_to) != "unknown"; EXPECT_TRUE(dummy || !dummy); // Suppresses warning that dummy is unused. } @@ -1618,8 +1619,9 @@ class GTestFlagSaverTest : public Test { GTEST_FLAG_SET(recreate_environments_when_repeating, true); GTEST_FLAG_SET(shuffle, false); GTEST_FLAG_SET(stack_trace_depth, kMaxStackTraceDepth); - GTEST_FLAG_SET(stream_result_to, ""); GTEST_FLAG_SET(throw_on_failure, false); + GTEST_FLAG_SET(machine_results, false); + GTEST_FLAG_SET(stream_result_to, ""); } // Restores the Google Test flags that the tests have modified. This will @@ -1648,8 +1650,9 @@ class GTestFlagSaverTest : public Test { EXPECT_TRUE(GTEST_FLAG_GET(recreate_environments_when_repeating)); EXPECT_FALSE(GTEST_FLAG_GET(shuffle)); EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG_GET(stack_trace_depth)); - EXPECT_STREQ("", GTEST_FLAG_GET(stream_result_to).c_str()); EXPECT_FALSE(GTEST_FLAG_GET(throw_on_failure)); + EXPECT_FALSE(GTEST_FLAG_GET(machine_results)); + EXPECT_STREQ("", GTEST_FLAG_GET(stream_result_to).c_str()); GTEST_FLAG_SET(also_run_disabled_tests, true); GTEST_FLAG_SET(break_on_failure, true); @@ -1667,8 +1670,9 @@ class GTestFlagSaverTest : public Test { GTEST_FLAG_SET(recreate_environments_when_repeating, false); GTEST_FLAG_SET(shuffle, true); GTEST_FLAG_SET(stack_trace_depth, 1); - GTEST_FLAG_SET(stream_result_to, "localhost:1234"); GTEST_FLAG_SET(throw_on_failure, true); + GTEST_FLAG_SET(machine_results, true); + GTEST_FLAG_SET(stream_result_to, "localhost:1234"); } private: @@ -5537,8 +5541,9 @@ struct Flags { recreate_environments_when_repeating(true), shuffle(false), stack_trace_depth(kMaxStackTraceDepth), - stream_result_to(""), - throw_on_failure(false) {} + throw_on_failure(false), + machine_results(false), + stream_result_to("") {} // Factory methods. @@ -5664,6 +5669,22 @@ struct Flags { return flags; } + // Creates a Flags struct where the GTEST_FLAG(throw_on_failure) flag has + // the given value. + static Flags ThrowOnFailure(bool throw_on_failure) { + Flags flags; + flags.throw_on_failure = throw_on_failure; + return flags; + } + + // Creates a Flags struct where GTEST_FLAG(machine_results) flag has + // the given value + static Flags MachineResults(bool machine_results) { + Flags flags; + flags.machine_results = machine_results; + return flags; + } + // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has // the given value. static Flags StreamResultTo(const char* stream_result_to) { @@ -5672,13 +5693,6 @@ struct Flags { return flags; } - // Creates a Flags struct where the gtest_throw_on_failure flag has - // the given value. - static Flags ThrowOnFailure(bool throw_on_failure) { - Flags flags; - flags.throw_on_failure = throw_on_failure; - return flags; - } // These fields store the flag values. bool also_run_disabled_tests; @@ -5696,8 +5710,9 @@ struct Flags { bool recreate_environments_when_repeating; bool shuffle; int32_t stack_trace_depth; - const char* stream_result_to; bool throw_on_failure; + bool machine_results; + const char* stream_result_to; }; // Fixture for testing ParseGoogleTestFlagsOnly(). @@ -5720,8 +5735,9 @@ class ParseFlagsTest : public Test { GTEST_FLAG_SET(recreate_environments_when_repeating, true); GTEST_FLAG_SET(shuffle, false); GTEST_FLAG_SET(stack_trace_depth, kMaxStackTraceDepth); - GTEST_FLAG_SET(stream_result_to, ""); GTEST_FLAG_SET(throw_on_failure, false); + GTEST_FLAG_SET(machine_results, false); + GTEST_FLAG_SET(stream_result_to, ""); } // Asserts that two narrow or wide string arrays are equal. @@ -5755,9 +5771,10 @@ class ParseFlagsTest : public Test { GTEST_FLAG_GET(recreate_environments_when_repeating)); EXPECT_EQ(expected.shuffle, GTEST_FLAG_GET(shuffle)); EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG_GET(stack_trace_depth)); + EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG_GET(throw_on_failure)); + EXPECT_EQ(expected.machine_results, GTEST_FLAG_GET(machine_results)); EXPECT_STREQ(expected.stream_result_to, GTEST_FLAG_GET(stream_result_to).c_str()); - EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG_GET(throw_on_failure)); } // Parses a command line (specified by argc1 and argv1), then @@ -6195,16 +6212,6 @@ TEST_F(ParseFlagsTest, StackTraceDepth) { GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false); } -TEST_F(ParseFlagsTest, StreamResultTo) { - const char* argv[] = {"foo.exe", "--gtest_stream_result_to=localhost:1234", - nullptr}; - - const char* argv2[] = {"foo.exe", nullptr}; - - GTEST_TEST_PARSING_FLAGS_(argv, argv2, - Flags::StreamResultTo("localhost:1234"), false); -} - // Tests parsing --gtest_throw_on_failure. TEST_F(ParseFlagsTest, ThrowOnFailureWithoutValue) { const char* argv[] = {"foo.exe", "--gtest_throw_on_failure", nullptr}; @@ -6233,6 +6240,22 @@ TEST_F(ParseFlagsTest, ThrowOnFailureTrue) { GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false); } +// Tests parsing --gtest_machine_results +TEST_F(ParseFlagsTest, MachineResultsTrue) { + // TODO +} + +// Tests parsing --gtest_stream_result_to flag that is set to localhost:1234 +TEST_F(ParseFlagsTest, StreamResultTo) { + const char* argv[] = {"foo.exe", "--gtest_stream_result_to=localhost:1234", + nullptr}; + + const char* argv2[] = {"foo.exe", nullptr}; + + GTEST_TEST_PARSING_FLAGS_(argv, argv2, + Flags::StreamResultTo("localhost:1234"), false); +} + // Tests parsing a bad --gtest_filter flag. TEST_F(ParseFlagsTest, FilterBad) { const char* argv[] = {"foo.exe", "--gtest_filter", nullptr};