Release a few bits and pieces of DFATAL that were left behind: flag parsing & some tests.

PiperOrigin-RevId: 592918704
Change-Id: Iacef0e069c012a04960211c032454244822f9634

4 files changed, 110 insertions, 3 deletions

diff --git a/absl/base/internal/raw_logging.h b/absl/base/internal/raw_logging.h
index b79550b2..d7cfbc57 100644
--- a/absl/base/internal/raw_logging.h
+++ b/absl/base/internal/raw_logging.h
@@ -108,6 +108,7 @@
 #define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
 #define ABSL_RAW_LOG_INTERNAL_ERROR ::absl::LogSeverity::kError
 #define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
+#define ABSL_RAW_LOG_INTERNAL_DFATAL ::absl::kLogDebugFatal
 #define ABSL_RAW_LOG_INTERNAL_LEVEL(severity) \
   ::absl::NormalizeLogSeverity(severity)
 
@@ -115,6 +116,7 @@
 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_WARNING
 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_ERROR
 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
+#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_DFATAL
 #define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_LEVEL(severity)
 
 namespace absl {
diff --git a/absl/base/log_severity_test.cc b/absl/base/log_severity_test.cc
index 16091a5b..3394ecd7 100644
--- a/absl/base/log_severity_test.cc
+++ b/absl/base/log_severity_test.cc
@@ -146,7 +146,12 @@ INSTANTIATE_TEST_SUITE_P(
            std::make_tuple("fatal", absl::LogSeverity::kFatal),
            std::make_tuple("kFatal", absl::LogSeverity::kFatal),
            std::make_tuple("FaTaL", absl::LogSeverity::kFatal),
-           std::make_tuple("KfAtAl", absl::LogSeverity::kFatal)));
+           std::make_tuple("KfAtAl", absl::LogSeverity::kFatal),
+           std::make_tuple("DFATAL", absl::kLogDebugFatal),
+           std::make_tuple("dfatal", absl::kLogDebugFatal),
+           std::make_tuple("kLogDebugFatal", absl::kLogDebugFatal),
+           std::make_tuple("dFaTaL", absl::kLogDebugFatal),
+           std::make_tuple("kLoGdEbUgFaTaL", absl::kLogDebugFatal)));
 TEST_P(ParseFlagFromEnumeratorTest, YieldsExpectedValue) {
   const absl::string_view to_parse = std::get<0>(GetParam());
   const absl::LogSeverity expected = std::get<1>(GetParam());
@@ -158,7 +163,8 @@ TEST_P(ParseFlagFromEnumeratorTest, YieldsExpectedValue) {
 
 using ParseFlagFromGarbageTest = TestWithParam<absl::string_view>;
 INSTANTIATE_TEST_SUITE_P(Instantiation, ParseFlagFromGarbageTest,
-                         Values("", "\0", " ", "garbage", "kkinfo", "I"));
+                         Values("", "\0", " ", "garbage", "kkinfo", "I",
+                                "kDFATAL", "LogDebugFatal", "lOgDeBuGfAtAl"));
 TEST_P(ParseFlagFromGarbageTest, ReturnsError) {
   const absl::string_view to_parse = GetParam();
   absl::LogSeverity value;
diff --git a/absl/flags/marshalling.cc b/absl/flags/marshalling.cc
index dc69754f..ca4a1305 100644
--- a/absl/flags/marshalling.cc
+++ b/absl/flags/marshalling.cc
@@ -247,6 +247,14 @@ bool AbslParseFlag(absl::string_view text, absl::LogSeverity* dst,
     *err = "no value provided";
     return false;
   }
+  if (absl::EqualsIgnoreCase(text, "dfatal")) {
+    *dst = absl::kLogDebugFatal;
+    return true;
+  }
+  if (absl::EqualsIgnoreCase(text, "klogdebugfatal")) {
+    *dst = absl::kLogDebugFatal;
+    return true;
+  }
   if (text.front() == 'k' || text.front() == 'K') text.remove_prefix(1);
   if (absl::EqualsIgnoreCase(text, "info")) {
     *dst = absl::LogSeverity::kInfo;
@@ -269,7 +277,8 @@ bool AbslParseFlag(absl::string_view text, absl::LogSeverity* dst,
     *dst = static_cast<absl::LogSeverity>(numeric_value);
     return true;
   }
-  *err = "only integers and absl::LogSeverity enumerators are accepted";
+  *err =
+      "only integers, absl::LogSeverity enumerators, and DFATAL are accepted";
   return false;
 }
 
diff --git a/absl/log/log_basic_test_impl.inc b/absl/log/log_basic_test_impl.inc
index f3400095..e2f33566 100644
--- a/absl/log/log_basic_test_impl.inc
+++ b/absl/log/log_basic_test_impl.inc
@@ -277,6 +277,96 @@ TEST_P(BasicLogDeathTest, QFatal) {
 }
 #endif
 
+#ifdef NDEBUG
+TEST_P(BasicLogTest, DFatal) {
+  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
+
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+
+  const int log_line = __LINE__ + 1;
+  auto do_log = [] { ABSL_TEST_LOG(DFATAL) << "hello world"; };
+
+  if (LoggingEnabledAt(absl::LogSeverity::kError)) {
+    EXPECT_CALL(
+        test_sink,
+        Send(AllOf(SourceFilename(Eq(__FILE__)),
+                   SourceBasename(Eq("log_basic_test_impl.inc")),
+                   SourceLine(Eq(log_line)), Prefix(IsTrue()),
+                   LogSeverity(Eq(absl::LogSeverity::kError)),
+                   TimestampInMatchWindow(),
+                   ThreadID(Eq(absl::base_internal::GetTID())),
+                   TextMessage(Eq("hello world")),
+                   Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
+                   ENCODED_MESSAGE(EqualsProto(R"pb(value {
+                                                      literal: "hello world"
+                                                    })pb")),
+                   Stacktrace(IsEmpty()))));
+  }
+
+  test_sink.StartCapturingLogs();
+  do_log();
+}
+
+#elif GTEST_HAS_DEATH_TEST
+TEST_P(BasicLogDeathTest, DFatal) {
+  // TODO(b/242568884): re-enable once bug is fixed.
+  // absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
+
+  const int log_line = __LINE__ + 1;
+  auto do_log = [] { ABSL_TEST_LOG(DFATAL) << "hello world"; };
+
+  EXPECT_EXIT(
+      {
+        absl::ScopedMockLog test_sink(
+            absl::MockLogDefault::kDisallowUnexpected);
+
+        EXPECT_CALL(test_sink, Send)
+            .Times(AnyNumber())
+            .WillRepeatedly(DeathTestUnexpectedLogging());
+
+        ::testing::InSequence s;
+
+        if (LoggingEnabledAt(absl::LogSeverity::kFatal)) {
+          // The first call without the stack trace.
+          EXPECT_CALL(
+              test_sink,
+              Send(AllOf(SourceFilename(Eq(__FILE__)),
+                         SourceBasename(Eq("log_basic_test_impl.inc")),
+                         SourceLine(Eq(log_line)), Prefix(IsTrue()),
+                         LogSeverity(Eq(absl::LogSeverity::kFatal)),
+                         TimestampInMatchWindow(),
+                         ThreadID(Eq(absl::base_internal::GetTID())),
+                         TextMessage(Eq("hello world")),
+                         Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
+                         ENCODED_MESSAGE(EqualsProto(
+                             R"pb(value { literal: "hello world" })pb")),
+                         Stacktrace(IsEmpty()))))
+              .WillOnce(DeathTestExpectedLogging());
+
+          // The second call with the stack trace.
+          EXPECT_CALL(
+              test_sink,
+              Send(AllOf(SourceFilename(Eq(__FILE__)),
+                         SourceBasename(Eq("log_basic_test_impl.inc")),
+                         SourceLine(Eq(log_line)), Prefix(IsTrue()),
+                         LogSeverity(Eq(absl::LogSeverity::kFatal)),
+                         TimestampInMatchWindow(),
+                         ThreadID(Eq(absl::base_internal::GetTID())),
+                         TextMessage(Eq("hello world")),
+                         Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
+                         ENCODED_MESSAGE(EqualsProto(
+                             R"pb(value { literal: "hello world" })pb")),
+                         Stacktrace(Not(IsEmpty())))))
+              .WillOnce(DeathTestExpectedLogging());
+        }
+
+        test_sink.StartCapturingLogs();
+        do_log();
+      },
+      DiedOfFatal, DeathTestValidateExpectations());
+}
+#endif
+
 TEST_P(BasicLogTest, Level) {
   absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());