summaryrefslogtreecommitdiffstats
path: root/googletest/test/gtest_unittest.cc
diff options
context:
space:
mode:
authorAbseil Team <absl-team@google.com>2021-07-02 21:01:11 (GMT)
committerDerek Mauro <dmauro@google.com>2021-07-07 18:34:19 (GMT)
commit977cffc4423a2d6c0df3fc9a7b5253b8f79c3f18 (patch)
treef984ad508b34bbdfb1812efaffe5b62e35ab70ae /googletest/test/gtest_unittest.cc
parent4cfd14984fb0ae68ae434ae6e82d67b75986adec (diff)
downloadgoogletest-977cffc4423a2d6c0df3fc9a7b5253b8f79c3f18.zip
googletest-977cffc4423a2d6c0df3fc9a7b5253b8f79c3f18.tar.gz
googletest-977cffc4423a2d6c0df3fc9a7b5253b8f79c3f18.tar.bz2
Googletest export
Introduce GTEST_FLAG_GET and GTEST_FLAG_SET macros. PiperOrigin-RevId: 382808313
Diffstat (limited to 'googletest/test/gtest_unittest.cc')
-rw-r--r--googletest/test/gtest_unittest.cc271
1 files changed, 124 insertions, 147 deletions
diff --git a/googletest/test/gtest_unittest.cc b/googletest/test/gtest_unittest.cc
index 402bb6d..3f2f082 100644
--- a/googletest/test/gtest_unittest.cc
+++ b/googletest/test/gtest_unittest.cc
@@ -37,23 +37,19 @@
// code once "gtest.h" has been #included.
// Do not move it after other gtest #includes.
TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
- bool dummy = testing::GTEST_FLAG(also_run_disabled_tests) ||
- testing::GTEST_FLAG(break_on_failure) ||
- testing::GTEST_FLAG(catch_exceptions) ||
- testing::GTEST_FLAG(color) != "unknown" ||
- testing::GTEST_FLAG(fail_fast) ||
- testing::GTEST_FLAG(filter) != "unknown" ||
- testing::GTEST_FLAG(list_tests) ||
- testing::GTEST_FLAG(output) != "unknown" ||
- testing::GTEST_FLAG(brief) || testing::GTEST_FLAG(print_time) ||
- testing::GTEST_FLAG(random_seed) ||
- testing::GTEST_FLAG(repeat) > 0 ||
- testing::GTEST_FLAG(recreate_environments_when_repeating) ||
- testing::GTEST_FLAG(show_internal_stack_frames) ||
- testing::GTEST_FLAG(shuffle) ||
- testing::GTEST_FLAG(stack_trace_depth) > 0 ||
- testing::GTEST_FLAG(stream_result_to) != "unknown" ||
- testing::GTEST_FLAG(throw_on_failure);
+ bool dummy =
+ GTEST_FLAG_GET(also_run_disabled_tests) ||
+ GTEST_FLAG_GET(break_on_failure) || GTEST_FLAG_GET(catch_exceptions) ||
+ GTEST_FLAG_GET(color) != "unknown" || GTEST_FLAG_GET(fail_fast) ||
+ GTEST_FLAG_GET(filter) != "unknown" || GTEST_FLAG_GET(list_tests) ||
+ GTEST_FLAG_GET(output) != "unknown" || GTEST_FLAG_GET(brief) ||
+ GTEST_FLAG_GET(print_time) || GTEST_FLAG_GET(random_seed) ||
+ GTEST_FLAG_GET(repeat) > 0 ||
+ 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);
EXPECT_TRUE(dummy || !dummy); // Suppresses warning that dummy is unused.
}
@@ -200,25 +196,6 @@ using testing::DoubleLE;
using testing::EmptyTestEventListener;
using testing::Environment;
using testing::FloatLE;
-using testing::GTEST_FLAG(also_run_disabled_tests);
-using testing::GTEST_FLAG(break_on_failure);
-using testing::GTEST_FLAG(catch_exceptions);
-using testing::GTEST_FLAG(color);
-using testing::GTEST_FLAG(death_test_use_fork);
-using testing::GTEST_FLAG(fail_fast);
-using testing::GTEST_FLAG(filter);
-using testing::GTEST_FLAG(list_tests);
-using testing::GTEST_FLAG(output);
-using testing::GTEST_FLAG(brief);
-using testing::GTEST_FLAG(print_time);
-using testing::GTEST_FLAG(random_seed);
-using testing::GTEST_FLAG(repeat);
-using testing::GTEST_FLAG(recreate_environments_when_repeating);
-using testing::GTEST_FLAG(show_internal_stack_frames);
-using testing::GTEST_FLAG(shuffle);
-using testing::GTEST_FLAG(stack_trace_depth);
-using testing::GTEST_FLAG(stream_result_to);
-using testing::GTEST_FLAG(throw_on_failure);
using testing::IsNotSubstring;
using testing::IsSubstring;
using testing::kMaxStackTraceDepth;
@@ -267,7 +244,7 @@ using testing::internal::kTestTypeIdInGoogleTest;
using testing::internal::NativeArray;
using testing::internal::OsStackTraceGetter;
using testing::internal::OsStackTraceGetterInterface;
-using testing::internal::ParseInt32Flag;
+using testing::internal::ParseFlag;
using testing::internal::RelationToSourceCopy;
using testing::internal::RelationToSourceReference;
using testing::internal::ShouldRunTestOnShard;
@@ -1599,24 +1576,24 @@ class GTestFlagSaverTest : public Test {
static void SetUpTestSuite() {
saver_ = new GTestFlagSaver;
- GTEST_FLAG(also_run_disabled_tests) = false;
- GTEST_FLAG(break_on_failure) = false;
- GTEST_FLAG(catch_exceptions) = false;
- GTEST_FLAG(death_test_use_fork) = false;
- GTEST_FLAG(color) = "auto";
- GTEST_FLAG(fail_fast) = false;
- GTEST_FLAG(filter) = "";
- GTEST_FLAG(list_tests) = false;
- GTEST_FLAG(output) = "";
- GTEST_FLAG(brief) = false;
- GTEST_FLAG(print_time) = true;
- GTEST_FLAG(random_seed) = 0;
- GTEST_FLAG(repeat) = 1;
- GTEST_FLAG(recreate_environments_when_repeating) = true;
- GTEST_FLAG(shuffle) = false;
- GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
- GTEST_FLAG(stream_result_to) = "";
- GTEST_FLAG(throw_on_failure) = false;
+ GTEST_FLAG_SET(also_run_disabled_tests, false);
+ GTEST_FLAG_SET(break_on_failure, false);
+ GTEST_FLAG_SET(catch_exceptions, false);
+ GTEST_FLAG_SET(death_test_use_fork, false);
+ GTEST_FLAG_SET(color, "auto");
+ GTEST_FLAG_SET(fail_fast, false);
+ GTEST_FLAG_SET(filter, "");
+ GTEST_FLAG_SET(list_tests, false);
+ GTEST_FLAG_SET(output, "");
+ GTEST_FLAG_SET(brief, false);
+ GTEST_FLAG_SET(print_time, true);
+ GTEST_FLAG_SET(random_seed, 0);
+ GTEST_FLAG_SET(repeat, 1);
+ 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);
}
// Restores the Google Test flags that the tests have modified. This will
@@ -1629,43 +1606,43 @@ class GTestFlagSaverTest : public Test {
// Verifies that the Google Test flags have their default values, and then
// modifies each of them.
void VerifyAndModifyFlags() {
- EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests));
- EXPECT_FALSE(GTEST_FLAG(break_on_failure));
- EXPECT_FALSE(GTEST_FLAG(catch_exceptions));
- EXPECT_STREQ("auto", GTEST_FLAG(color).c_str());
- EXPECT_FALSE(GTEST_FLAG(death_test_use_fork));
- EXPECT_FALSE(GTEST_FLAG(fail_fast));
- EXPECT_STREQ("", GTEST_FLAG(filter).c_str());
- EXPECT_FALSE(GTEST_FLAG(list_tests));
- EXPECT_STREQ("", GTEST_FLAG(output).c_str());
- EXPECT_FALSE(GTEST_FLAG(brief));
- EXPECT_TRUE(GTEST_FLAG(print_time));
- EXPECT_EQ(0, GTEST_FLAG(random_seed));
- EXPECT_EQ(1, GTEST_FLAG(repeat));
- EXPECT_TRUE(GTEST_FLAG(recreate_environments_when_repeating));
- EXPECT_FALSE(GTEST_FLAG(shuffle));
- EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth));
- EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str());
- EXPECT_FALSE(GTEST_FLAG(throw_on_failure));
-
- GTEST_FLAG(also_run_disabled_tests) = true;
- GTEST_FLAG(break_on_failure) = true;
- GTEST_FLAG(catch_exceptions) = true;
- GTEST_FLAG(color) = "no";
- GTEST_FLAG(death_test_use_fork) = true;
- GTEST_FLAG(fail_fast) = true;
- GTEST_FLAG(filter) = "abc";
- GTEST_FLAG(list_tests) = true;
- GTEST_FLAG(output) = "xml:foo.xml";
- GTEST_FLAG(brief) = true;
- GTEST_FLAG(print_time) = false;
- GTEST_FLAG(random_seed) = 1;
- GTEST_FLAG(repeat) = 100;
- GTEST_FLAG(recreate_environments_when_repeating) = false;
- GTEST_FLAG(shuffle) = true;
- GTEST_FLAG(stack_trace_depth) = 1;
- GTEST_FLAG(stream_result_to) = "localhost:1234";
- GTEST_FLAG(throw_on_failure) = true;
+ EXPECT_FALSE(GTEST_FLAG_GET(also_run_disabled_tests));
+ EXPECT_FALSE(GTEST_FLAG_GET(break_on_failure));
+ EXPECT_FALSE(GTEST_FLAG_GET(catch_exceptions));
+ EXPECT_STREQ("auto", GTEST_FLAG_GET(color).c_str());
+ EXPECT_FALSE(GTEST_FLAG_GET(death_test_use_fork));
+ EXPECT_FALSE(GTEST_FLAG_GET(fail_fast));
+ EXPECT_STREQ("", GTEST_FLAG_GET(filter).c_str());
+ EXPECT_FALSE(GTEST_FLAG_GET(list_tests));
+ EXPECT_STREQ("", GTEST_FLAG_GET(output).c_str());
+ EXPECT_FALSE(GTEST_FLAG_GET(brief));
+ EXPECT_TRUE(GTEST_FLAG_GET(print_time));
+ EXPECT_EQ(0, GTEST_FLAG_GET(random_seed));
+ EXPECT_EQ(1, GTEST_FLAG_GET(repeat));
+ 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));
+
+ GTEST_FLAG_SET(also_run_disabled_tests, true);
+ GTEST_FLAG_SET(break_on_failure, true);
+ GTEST_FLAG_SET(catch_exceptions, true);
+ GTEST_FLAG_SET(color, "no");
+ GTEST_FLAG_SET(death_test_use_fork, true);
+ GTEST_FLAG_SET(fail_fast, true);
+ GTEST_FLAG_SET(filter, "abc");
+ GTEST_FLAG_SET(list_tests, true);
+ GTEST_FLAG_SET(output, "xml:foo.xml");
+ GTEST_FLAG_SET(brief, true);
+ GTEST_FLAG_SET(print_time, false);
+ GTEST_FLAG_SET(random_seed, 1);
+ GTEST_FLAG_SET(repeat, 100);
+ 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);
}
private:
@@ -1781,29 +1758,29 @@ TEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) {
}
#endif // !GTEST_OS_WINDOWS_MOBILE
-// Tests ParseInt32Flag().
+// Tests ParseFlag().
// Tests that ParseInt32Flag() returns false and doesn't change the
// output value when the flag has wrong format
TEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) {
int32_t value = 123;
- EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value));
+ EXPECT_FALSE(ParseFlag("--a=100", "b", &value));
EXPECT_EQ(123, value);
- EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value));
+ EXPECT_FALSE(ParseFlag("a=100", "a", &value));
EXPECT_EQ(123, value);
}
-// Tests that ParseInt32Flag() returns false and doesn't change the
+// Tests that ParseFlag() returns false and doesn't change the
// output value when the flag overflows as an Int32.
TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) {
printf("(expecting 2 warnings)\n");
int32_t value = 123;
- EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value));
+ EXPECT_FALSE(ParseFlag("--abc=12345678987654321", "abc", &value));
EXPECT_EQ(123, value);
- EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value));
+ EXPECT_FALSE(ParseFlag("--abc=-12345678987654321", "abc", &value));
EXPECT_EQ(123, value);
}
@@ -1814,10 +1791,10 @@ TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
printf("(expecting 2 warnings)\n");
int32_t value = 123;
- EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value));
+ EXPECT_FALSE(ParseFlag("--abc=A1", "abc", &value));
EXPECT_EQ(123, value);
- EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value));
+ EXPECT_FALSE(ParseFlag("--abc=12X", "abc", &value));
EXPECT_EQ(123, value);
}
@@ -1826,11 +1803,10 @@ TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
// the range of an Int32.
TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
int32_t value = 123;
- EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value));
+ EXPECT_TRUE(ParseFlag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value));
EXPECT_EQ(456, value);
- EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789",
- "abc", &value));
+ EXPECT_TRUE(ParseFlag("--" GTEST_FLAG_PREFIX_ "abc=-789", "abc", &value));
EXPECT_EQ(-789, value);
}
@@ -5756,23 +5732,23 @@ class ParseFlagsTest : public Test {
protected:
// Clears the flags before each test.
void SetUp() override {
- GTEST_FLAG(also_run_disabled_tests) = false;
- GTEST_FLAG(break_on_failure) = false;
- GTEST_FLAG(catch_exceptions) = false;
- GTEST_FLAG(death_test_use_fork) = false;
- GTEST_FLAG(fail_fast) = false;
- GTEST_FLAG(filter) = "";
- GTEST_FLAG(list_tests) = false;
- GTEST_FLAG(output) = "";
- GTEST_FLAG(brief) = false;
- GTEST_FLAG(print_time) = true;
- GTEST_FLAG(random_seed) = 0;
- GTEST_FLAG(repeat) = 1;
- GTEST_FLAG(recreate_environments_when_repeating) = true;
- GTEST_FLAG(shuffle) = false;
- GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
- GTEST_FLAG(stream_result_to) = "";
- GTEST_FLAG(throw_on_failure) = false;
+ GTEST_FLAG_SET(also_run_disabled_tests, false);
+ GTEST_FLAG_SET(break_on_failure, false);
+ GTEST_FLAG_SET(catch_exceptions, false);
+ GTEST_FLAG_SET(death_test_use_fork, false);
+ GTEST_FLAG_SET(fail_fast, false);
+ GTEST_FLAG_SET(filter, "");
+ GTEST_FLAG_SET(list_tests, false);
+ GTEST_FLAG_SET(output, "");
+ GTEST_FLAG_SET(brief, false);
+ GTEST_FLAG_SET(print_time, true);
+ GTEST_FLAG_SET(random_seed, 0);
+ GTEST_FLAG_SET(repeat, 1);
+ 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);
}
// Asserts that two narrow or wide string arrays are equal.
@@ -5789,25 +5765,26 @@ class ParseFlagsTest : public Test {
// Verifies that the flag values match the expected values.
static void CheckFlags(const Flags& expected) {
EXPECT_EQ(expected.also_run_disabled_tests,
- GTEST_FLAG(also_run_disabled_tests));
- EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));
- EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));
- EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));
- EXPECT_EQ(expected.fail_fast, GTEST_FLAG(fail_fast));
- EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());
- EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));
- EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());
- EXPECT_EQ(expected.brief, GTEST_FLAG(brief));
- EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time));
- EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed));
- EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat));
+ GTEST_FLAG_GET(also_run_disabled_tests));
+ EXPECT_EQ(expected.break_on_failure, GTEST_FLAG_GET(break_on_failure));
+ EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG_GET(catch_exceptions));
+ EXPECT_EQ(expected.death_test_use_fork,
+ GTEST_FLAG_GET(death_test_use_fork));
+ EXPECT_EQ(expected.fail_fast, GTEST_FLAG_GET(fail_fast));
+ EXPECT_STREQ(expected.filter, GTEST_FLAG_GET(filter).c_str());
+ EXPECT_EQ(expected.list_tests, GTEST_FLAG_GET(list_tests));
+ EXPECT_STREQ(expected.output, GTEST_FLAG_GET(output).c_str());
+ EXPECT_EQ(expected.brief, GTEST_FLAG_GET(brief));
+ EXPECT_EQ(expected.print_time, GTEST_FLAG_GET(print_time));
+ EXPECT_EQ(expected.random_seed, GTEST_FLAG_GET(random_seed));
+ EXPECT_EQ(expected.repeat, GTEST_FLAG_GET(repeat));
EXPECT_EQ(expected.recreate_environments_when_repeating,
- GTEST_FLAG(recreate_environments_when_repeating));
- EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle));
- EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth));
+ 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_STREQ(expected.stream_result_to,
- GTEST_FLAG(stream_result_to).c_str());
- EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure));
+ 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
@@ -6639,7 +6616,7 @@ TEST(StreamingAssertionsTest, AnyThrow) {
// Tests that Google Test correctly decides whether to use colors in the output.
TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
- GTEST_FLAG(color) = "yes";
+ GTEST_FLAG_SET(color, "yes");
SetEnv("TERM", "xterm"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
@@ -6653,18 +6630,18 @@ TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {
SetEnv("TERM", "dumb"); // TERM doesn't support colors.
- GTEST_FLAG(color) = "True";
+ GTEST_FLAG_SET(color, "True");
EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
- GTEST_FLAG(color) = "t";
+ GTEST_FLAG_SET(color, "t");
EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
- GTEST_FLAG(color) = "1";
+ GTEST_FLAG_SET(color, "1");
EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
}
TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
- GTEST_FLAG(color) = "no";
+ GTEST_FLAG_SET(color, "no");
SetEnv("TERM", "xterm"); // TERM supports colors.
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
@@ -6678,18 +6655,18 @@ TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {
SetEnv("TERM", "xterm"); // TERM supports colors.
- GTEST_FLAG(color) = "F";
+ GTEST_FLAG_SET(color, "F");
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
- GTEST_FLAG(color) = "0";
+ GTEST_FLAG_SET(color, "0");
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
- GTEST_FLAG(color) = "unknown";
+ GTEST_FLAG_SET(color, "unknown");
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
}
TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
- GTEST_FLAG(color) = "auto";
+ GTEST_FLAG_SET(color, "auto");
SetEnv("TERM", "xterm"); // TERM supports colors.
EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY.
@@ -6697,7 +6674,7 @@ TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
}
TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
- GTEST_FLAG(color) = "auto";
+ GTEST_FLAG_SET(color, "auto");
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
// On Windows, we ignore the TERM variable as it's usually not set.