re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/log/log_format_test.cc

@@ -15,12 +15,14 @@
 
 #include <math.h>
 
+#include <cstring>
 #include <iomanip>
 #include <ios>
 #include <limits>
 #include <ostream>
 #include <sstream>
 #include <string>
+#include <string_view>
 #include <type_traits>
 
 #ifdef __ANDROID__
@@ -28,6 +30,7 @@
 #endif
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "absl/base/config.h"
 #include "absl/log/check.h"
 #include "absl/log/internal/test_matchers.h"
 #include "absl/log/log.h"
@@ -44,6 +47,7 @@ using ::absl::log_internal::MatchesOstream;
 using ::absl::log_internal::RawEncodedMessage;
 using ::absl::log_internal::TextMessage;
 using ::absl::log_internal::TextPrefix;
+using ::testing::_;
 using ::testing::AllOf;
 using ::testing::AnyOf;
 using ::testing::Each;
@@ -69,6 +73,7 @@ std::ostringstream ComparisonStream() {
 
 TEST(LogFormatTest, NoMessage) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int log_line = __LINE__ + 1;
   auto do_log = [] { LOG(INFO); };
@@ -91,6 +96,7 @@ TYPED_TEST_SUITE(CharLogFormatTest, CharTypes);
 
 TYPED_TEST(CharLogFormatTest, Printable) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = 'x';
   auto comparison_stream = ComparisonStream();
@@ -108,6 +114,7 @@ TYPED_TEST(CharLogFormatTest, Printable) {
 
 TYPED_TEST(CharLogFormatTest, Unprintable) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   constexpr auto value = static_cast<TypeParam>(0xeeu);
   auto comparison_stream = ComparisonStream();
@@ -124,6 +131,35 @@ TYPED_TEST(CharLogFormatTest, Unprintable) {
   LOG(INFO) << value;
 }
 
+TEST(WideCharLogFormatTest, Printable) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq("€")),
+                                    ENCODED_MESSAGE(HasValues(
+                                        ElementsAre(ValueWithStr(Eq("€"))))))));
+
+  test_sink.StartCapturingLogs();
+  const wchar_t value = L'\u20AC';
+  LOG(INFO) << value;
+}
+
+TEST(WideCharLogFormatTest, Unprintable) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  // Using NEL (Next Line) Unicode character (U+0085).
+  // It is encoded as "\xC2\x85" in UTF-8.
+  constexpr wchar_t wide_value = L'\u0085';
+  constexpr char value[] = "\xC2\x85";
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(value)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq(value))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << wide_value;
+}
+
 template <typename T>
 class UnsignedIntLogFormatTest : public testing::Test {};
 using UnsignedIntTypes = Types<unsigned short, unsigned int,        // NOLINT
@@ -132,6 +168,7 @@ TYPED_TEST_SUITE(UnsignedIntLogFormatTest, UnsignedIntTypes);
 
 TYPED_TEST(UnsignedIntLogFormatTest, Positive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = 224;
   auto comparison_stream = ComparisonStream();
@@ -150,6 +187,7 @@ TYPED_TEST(UnsignedIntLogFormatTest, Positive) {
 
 TYPED_TEST(UnsignedIntLogFormatTest, BitfieldPositive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const struct {
     TypeParam bits : 6;
@@ -175,6 +213,7 @@ TYPED_TEST_SUITE(SignedIntLogFormatTest, SignedIntTypes);
 
 TYPED_TEST(SignedIntLogFormatTest, Positive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = 224;
   auto comparison_stream = ComparisonStream();
@@ -193,6 +232,7 @@ TYPED_TEST(SignedIntLogFormatTest, Positive) {
 
 TYPED_TEST(SignedIntLogFormatTest, Negative) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = -112;
   auto comparison_stream = ComparisonStream();
@@ -211,6 +251,7 @@ TYPED_TEST(SignedIntLogFormatTest, Negative) {
 
 TYPED_TEST(SignedIntLogFormatTest, BitfieldPositive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const struct {
     TypeParam bits : 6;
@@ -230,6 +271,7 @@ TYPED_TEST(SignedIntLogFormatTest, BitfieldPositive) {
 
 TYPED_TEST(SignedIntLogFormatTest, BitfieldNegative) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const struct {
     TypeParam bits : 6;
@@ -274,6 +316,7 @@ TYPED_TEST_SUITE(UnsignedEnumLogFormatTest, UnsignedEnumTypes);
 
 TYPED_TEST(UnsignedEnumLogFormatTest, Positive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = static_cast<TypeParam>(224);
   auto comparison_stream = ComparisonStream();
@@ -292,6 +335,7 @@ TYPED_TEST(UnsignedEnumLogFormatTest, Positive) {
 
 TYPED_TEST(UnsignedEnumLogFormatTest, BitfieldPositive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const struct {
     TypeParam bits : 6;
@@ -334,6 +378,7 @@ TYPED_TEST_SUITE(SignedEnumLogFormatTest, SignedEnumTypes);
 
 TYPED_TEST(SignedEnumLogFormatTest, Positive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = static_cast<TypeParam>(224);
   auto comparison_stream = ComparisonStream();
@@ -352,6 +397,7 @@ TYPED_TEST(SignedEnumLogFormatTest, Positive) {
 
 TYPED_TEST(SignedEnumLogFormatTest, Negative) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = static_cast<TypeParam>(-112);
   auto comparison_stream = ComparisonStream();
@@ -370,6 +416,7 @@ TYPED_TEST(SignedEnumLogFormatTest, Negative) {
 
 TYPED_TEST(SignedEnumLogFormatTest, BitfieldPositive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const struct {
     TypeParam bits : 6;
@@ -389,6 +436,7 @@ TYPED_TEST(SignedEnumLogFormatTest, BitfieldPositive) {
 
 TYPED_TEST(SignedEnumLogFormatTest, BitfieldNegative) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const struct {
     TypeParam bits : 6;
@@ -410,6 +458,7 @@ TYPED_TEST(SignedEnumLogFormatTest, BitfieldNegative) {
 
 TEST(FloatLogFormatTest, Positive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const float value = 6.02e23f;
   auto comparison_stream = ComparisonStream();
@@ -427,6 +476,7 @@ TEST(FloatLogFormatTest, Positive) {
 
 TEST(FloatLogFormatTest, Negative) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const float value = -6.02e23f;
   auto comparison_stream = ComparisonStream();
@@ -444,6 +494,7 @@ TEST(FloatLogFormatTest, Negative) {
 
 TEST(FloatLogFormatTest, NegativeExponent) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const float value = 6.02e-23f;
   auto comparison_stream = ComparisonStream();
@@ -461,6 +512,7 @@ TEST(FloatLogFormatTest, NegativeExponent) {
 
 TEST(DoubleLogFormatTest, Positive) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 6.02e23;
   auto comparison_stream = ComparisonStream();
@@ -478,6 +530,7 @@ TEST(DoubleLogFormatTest, Positive) {
 
 TEST(DoubleLogFormatTest, Negative) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = -6.02e23;
   auto comparison_stream = ComparisonStream();
@@ -495,6 +548,7 @@ TEST(DoubleLogFormatTest, Negative) {
 
 TEST(DoubleLogFormatTest, NegativeExponent) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 6.02e-23;
   auto comparison_stream = ComparisonStream();
@@ -517,6 +571,7 @@ TYPED_TEST_SUITE(FloatingPointLogFormatTest, FloatingPointTypes);
 
 TYPED_TEST(FloatingPointLogFormatTest, Zero) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = 0.0;
   auto comparison_stream = ComparisonStream();
@@ -534,6 +589,7 @@ TYPED_TEST(FloatingPointLogFormatTest, Zero) {
 
 TYPED_TEST(FloatingPointLogFormatTest, Integer) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = 1.0;
   auto comparison_stream = ComparisonStream();
@@ -551,6 +607,7 @@ TYPED_TEST(FloatingPointLogFormatTest, Integer) {
 
 TYPED_TEST(FloatingPointLogFormatTest, Infinity) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = std::numeric_limits<TypeParam>::infinity();
   auto comparison_stream = ComparisonStream();
@@ -569,6 +626,7 @@ TYPED_TEST(FloatingPointLogFormatTest, Infinity) {
 
 TYPED_TEST(FloatingPointLogFormatTest, NegativeInfinity) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = -std::numeric_limits<TypeParam>::infinity();
   auto comparison_stream = ComparisonStream();
@@ -587,6 +645,7 @@ TYPED_TEST(FloatingPointLogFormatTest, NegativeInfinity) {
 
 TYPED_TEST(FloatingPointLogFormatTest, NaN) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = std::numeric_limits<TypeParam>::quiet_NaN();
   auto comparison_stream = ComparisonStream();
@@ -604,6 +663,7 @@ TYPED_TEST(FloatingPointLogFormatTest, NaN) {
 
 TYPED_TEST(FloatingPointLogFormatTest, NegativeNaN) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value =
       std::copysign(std::numeric_limits<TypeParam>::quiet_NaN(), -1.0);
@@ -635,11 +695,12 @@ TYPED_TEST(FloatingPointLogFormatTest, NegativeNaN) {
 
 template <typename T>
 class VoidPtrLogFormatTest : public testing::Test {};
-using VoidPtrTypes = Types<void *, const void *>;
+using VoidPtrTypes = Types<void*, const void*>;
 TYPED_TEST_SUITE(VoidPtrLogFormatTest, VoidPtrTypes);
 
 TYPED_TEST(VoidPtrLogFormatTest, Null) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = nullptr;
   auto comparison_stream = ComparisonStream();
@@ -657,6 +718,7 @@ TYPED_TEST(VoidPtrLogFormatTest, Null) {
 
 TYPED_TEST(VoidPtrLogFormatTest, NonNull) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = reinterpret_cast<TypeParam>(0xdeadbeefULL);
   auto comparison_stream = ComparisonStream();
@@ -676,26 +738,35 @@ TYPED_TEST(VoidPtrLogFormatTest, NonNull) {
 
 template <typename T>
 class VolatilePtrLogFormatTest : public testing::Test {};
-using VolatilePtrTypes =
-    Types<volatile void*, const volatile void*, volatile char*,
-          const volatile char*, volatile signed char*,
-          const volatile signed char*, volatile unsigned char*,
-          const volatile unsigned char*>;
+using VolatilePtrTypes = Types<
+    volatile void*, const volatile void*, volatile char*, const volatile char*,
+    volatile signed char*, const volatile signed char*, volatile unsigned char*,
+    const volatile unsigned char*, volatile wchar_t*, const volatile wchar_t*>;
 TYPED_TEST_SUITE(VolatilePtrLogFormatTest, VolatilePtrTypes);
 
 TYPED_TEST(VolatilePtrLogFormatTest, Null) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = nullptr;
   auto comparison_stream = ComparisonStream();
   comparison_stream << value;
 
+  // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1147r1.html
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202302L
+  EXPECT_CALL(
+      test_sink,
+      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
+                 TextMessage(AnyOf(Eq("(nil)"), Eq("0"), Eq("0x0"),
+                                   Eq("00000000"), Eq("0000000000000000"))))));
+#else
   EXPECT_CALL(
       test_sink,
       Send(AllOf(
           TextMessage(MatchesOstream(comparison_stream)),
           TextMessage(Eq("false")),
           ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("false"))))))));
+#endif
 
   test_sink.StartCapturingLogs();
   LOG(INFO) << value;
@@ -703,17 +774,29 @@ TYPED_TEST(VolatilePtrLogFormatTest, Null) {
 
 TYPED_TEST(VolatilePtrLogFormatTest, NonNull) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const TypeParam value = reinterpret_cast<TypeParam>(0xdeadbeefLL);
   auto comparison_stream = ComparisonStream();
   comparison_stream << value;
 
+  // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1147r1.html
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202302L
+  EXPECT_CALL(test_sink,
+              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
+                         TextMessage(AnyOf(Eq("0xdeadbeef"), Eq("DEADBEEF"),
+                                           Eq("00000000DEADBEEF"))),
+                         ENCODED_MESSAGE(HasValues(ElementsAre(
+                             AnyOf(ValueWithStr(Eq("0xdeadbeef")),
+                                   ValueWithStr(Eq("00000000DEADBEEF")))))))));
+#else
   EXPECT_CALL(
       test_sink,
       Send(AllOf(
           TextMessage(MatchesOstream(comparison_stream)),
           TextMessage(Eq("true")),
           ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("true"))))))));
+#endif
 
   test_sink.StartCapturingLogs();
   LOG(INFO) << value;
@@ -727,6 +810,7 @@ TYPED_TEST_SUITE(CharPtrLogFormatTest, CharPtrTypes);
 
 TYPED_TEST(CharPtrLogFormatTest, Null) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   // Streaming `([cv] char *)nullptr` into a `std::ostream` is UB, and some C++
   // standard library implementations choose to crash.  We take measures to log
@@ -747,6 +831,7 @@ TYPED_TEST(CharPtrLogFormatTest, Null) {
 
 TYPED_TEST(CharPtrLogFormatTest, NonNull) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   TypeParam data[] = {'v', 'a', 'l', 'u', 'e', '\0'};
   TypeParam* const value = data;
@@ -764,8 +849,43 @@ TYPED_TEST(CharPtrLogFormatTest, NonNull) {
   LOG(INFO) << value;
 }
 
+template <typename T>
+class WideCharPtrLogFormatTest : public testing::Test {};
+using WideCharPtrTypes = Types<wchar_t, const wchar_t>;
+TYPED_TEST_SUITE(WideCharPtrLogFormatTest, WideCharPtrTypes);
+
+TYPED_TEST(WideCharPtrLogFormatTest, Null) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  TypeParam* const value = nullptr;
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq("(null)")),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq("(null)"))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+TYPED_TEST(WideCharPtrLogFormatTest, NonNull) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  TypeParam data[] = {'v', 'a', 'l', 'u', 'e', '\0'};
+  TypeParam* const value = data;
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq("value")),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq("value"))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
 TEST(BoolLogFormatTest, True) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const bool value = true;
   auto comparison_stream = ComparisonStream();
@@ -784,6 +904,7 @@ TEST(BoolLogFormatTest, True) {
 
 TEST(BoolLogFormatTest, False) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const bool value = false;
   auto comparison_stream = ComparisonStream();
@@ -802,6 +923,7 @@ TEST(BoolLogFormatTest, False) {
 
 TEST(LogFormatTest, StringLiteral) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   auto comparison_stream = ComparisonStream();
   comparison_stream << "value";
@@ -816,8 +938,21 @@ TEST(LogFormatTest, StringLiteral) {
   LOG(INFO) << "value";
 }
 
+TEST(LogFormatTest, WideStringLiteral) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq("value")),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithLiteral(Eq("value"))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << L"value";
+}
+
 TEST(LogFormatTest, CharArray) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   char value[] = "value";
   auto comparison_stream = ComparisonStream();
@@ -834,6 +969,203 @@ TEST(LogFormatTest, CharArray) {
   LOG(INFO) << value;
 }
 
+TEST(LogFormatTest, WideCharArray) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  wchar_t value[] = L"value";
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq("value")),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq("value"))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+// Comprehensive test string for validating wchar_t to UTF-8 conversion.
+// See details in absl/strings/internal/utf8_test.cc.
+//
+// clang-format off
+#define ABSL_LOG_INTERNAL_WIDE_LITERAL L"Holá €1 你好 שָׁלוֹם 👍🏻🇺🇸👩‍❤️‍💋‍👨 中"
+#define ABSL_LOG_INTERNAL_UTF8_LITERAL u8"Holá €1 你好 שָׁלוֹם 👍🏻🇺🇸👩‍❤️‍💋‍👨 中"
+// clang-format on
+
+absl::string_view GetUtf8TestString() {
+  // `u8""` forces UTF-8 encoding; MSVC will default to e.g. CP1252 (and warn)
+  // without it. However, the resulting character type differs between pre-C++20
+  // (`char`) and C++20 (`char8_t`). So we reinterpret_cast to `char*` and wrap
+  // it in a `string_view`.
+  static const absl::string_view kUtf8TestString(
+      reinterpret_cast<const char*>(ABSL_LOG_INTERNAL_UTF8_LITERAL),
+      sizeof(ABSL_LOG_INTERNAL_UTF8_LITERAL) - 1);
+  return kUtf8TestString;
+}
+
+template <typename T>
+class WideStringLogFormatTest : public testing::Test {};
+using StringTypes =
+    Types<std::wstring, const std::wstring, wchar_t[], const wchar_t*>;
+TYPED_TEST_SUITE(WideStringLogFormatTest, StringTypes);
+
+TYPED_TEST(WideStringLogFormatTest, NonLiterals) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  TypeParam value = ABSL_LOG_INTERNAL_WIDE_LITERAL;
+  absl::string_view utf8_value = GetUtf8TestString();
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(utf8_value)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq(utf8_value))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+TEST(WideStringLogFormatTest, StringView) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  std::wstring_view value = ABSL_LOG_INTERNAL_WIDE_LITERAL;
+  absl::string_view utf8_value = GetUtf8TestString();
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(utf8_value)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq(utf8_value))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+TEST(WideStringLogFormatTest, Literal) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  absl::string_view utf8_value = GetUtf8TestString();
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(utf8_value)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithLiteral(Eq(utf8_value))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << ABSL_LOG_INTERNAL_WIDE_LITERAL;
+}
+
+#undef ABSL_LOG_INTERNAL_WIDE_LITERAL
+#undef ABSL_LOG_INTERNAL_UTF8_LITERAL
+
+TYPED_TEST(WideStringLogFormatTest, IsolatedLowSurrogatesAreReplaced) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  TypeParam value = L"AAA \xDC00 BBB";
+  // NOLINTNEXTLINE(readability/utf8)
+  absl::string_view utf8_value = "AAA � BBB";
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(utf8_value)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq(utf8_value))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+TYPED_TEST(WideStringLogFormatTest,
+           DISABLED_IsolatedHighSurrogatesAreReplaced) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  TypeParam value = L"AAA \xD800 BBB";
+  // NOLINTNEXTLINE(readability/utf8)
+  absl::string_view utf8_value = "AAA � BBB";
+  // Currently, this is "AAA \xF0\x90 BBB".
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(utf8_value)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq(utf8_value))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+TYPED_TEST(WideStringLogFormatTest,
+           DISABLED_ConsecutiveHighSurrogatesAreReplaced) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  TypeParam value = L"AAA \xD800\xD800 BBB";
+  // NOLINTNEXTLINE(readability/utf8)
+  absl::string_view utf8_value = "AAA �� BBB";
+  // Currently, this is "AAA \xF0\x90\xF0\x90 BBB".
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(utf8_value)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq(utf8_value))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+TYPED_TEST(WideStringLogFormatTest,
+           DISABLED_HighHighLowSurrogateSequencesAreReplaced) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  TypeParam value = L"AAA \xD800\xD800\xDC00 BBB";
+  // NOLINTNEXTLINE(readability/utf8)
+  absl::string_view utf8_value = "AAA �𐀀 BBB";
+  // Currently, this is "AAA \xF0\x90𐀀 BBB".
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(utf8_value)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq(utf8_value))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+TYPED_TEST(WideStringLogFormatTest,
+           DISABLED_TrailingHighSurrogatesAreReplaced) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  TypeParam value = L"AAA \xD800";
+  // NOLINTNEXTLINE(readability/utf8)
+  absl::string_view utf8_value = "AAA �";
+  // Currently, this is "AAA \xF0\x90".
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq(utf8_value)),
+                                    ENCODED_MESSAGE(HasValues(ElementsAre(
+                                        ValueWithStr(Eq(utf8_value))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+TYPED_TEST(WideStringLogFormatTest, EmptyWideString) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  TypeParam value = L"";
+
+  EXPECT_CALL(test_sink, Send(AllOf(TextMessage(Eq("")),
+                                    ENCODED_MESSAGE(HasValues(
+                                        ElementsAre(ValueWithStr(Eq(""))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << value;
+}
+
+TEST(WideStringLogFormatTest, MixedNarrowAndWideStrings) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+
+  EXPECT_CALL(test_sink, Log(_, _, "1234"));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << "1" << L"2" << "3" << L"4";
+}
+
 class CustomClass {};
 std::ostream& operator<<(std::ostream& os, const CustomClass&) {
   return os << "CustomClass{}";
@@ -841,6 +1173,7 @@ std::ostream& operator<<(std::ostream& os, const CustomClass&) {
 
 TEST(LogFormatTest, Custom) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   CustomClass value;
   auto comparison_stream = ComparisonStream();
@@ -867,6 +1200,7 @@ std::ostream& operator<<(std::ostream& os, const CustomClassNonCopyable&) {
 
 TEST(LogFormatTest, CustomNonCopyable) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   CustomClassNonCopyable value;
   auto comparison_stream = ComparisonStream();
@@ -894,6 +1228,7 @@ struct Point {
 
 TEST(LogFormatTest, AbslStringifyExample) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   Point p;
 
@@ -925,6 +1260,7 @@ ABSL_ATTRIBUTE_UNUSED std::ostream& operator<<(
 
 TEST(LogFormatTest, CustomWithAbslStringifyAndOstream) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   PointWithAbslStringifiyAndOstream p;
 
@@ -948,6 +1284,7 @@ struct PointStreamsNothing {
 
 TEST(LogFormatTest, AbslStringifyStreamsNothing) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   PointStreamsNothing p;
 
@@ -974,6 +1311,7 @@ struct PointMultipleAppend {
 
 TEST(LogFormatTest, AbslStringifyMultipleAppend) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   PointMultipleAppend p;
 
@@ -989,6 +1327,7 @@ TEST(LogFormatTest, AbslStringifyMultipleAppend) {
 
 TEST(ManipulatorLogFormatTest, BoolAlphaTrue) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const bool value = true;
   auto comparison_stream = ComparisonStream();
@@ -1013,6 +1352,7 @@ TEST(ManipulatorLogFormatTest, BoolAlphaTrue) {
 
 TEST(ManipulatorLogFormatTest, BoolAlphaFalse) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const bool value = false;
   auto comparison_stream = ComparisonStream();
@@ -1037,6 +1377,7 @@ TEST(ManipulatorLogFormatTest, BoolAlphaFalse) {
 
 TEST(ManipulatorLogFormatTest, ShowPoint) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 77.0;
   auto comparison_stream = ComparisonStream();
@@ -1061,6 +1402,7 @@ TEST(ManipulatorLogFormatTest, ShowPoint) {
 
 TEST(ManipulatorLogFormatTest, ShowPos) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 77;
   auto comparison_stream = ComparisonStream();
@@ -1084,6 +1426,7 @@ TEST(ManipulatorLogFormatTest, ShowPos) {
 
 TEST(ManipulatorLogFormatTest, UppercaseFloat) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 7.7e7;
   auto comparison_stream = ComparisonStream();
@@ -1108,6 +1451,7 @@ TEST(ManipulatorLogFormatTest, UppercaseFloat) {
 
 TEST(ManipulatorLogFormatTest, Hex) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 0x77;
   auto comparison_stream = ComparisonStream();
@@ -1125,6 +1469,7 @@ TEST(ManipulatorLogFormatTest, Hex) {
 
 TEST(ManipulatorLogFormatTest, Oct) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 077;
   auto comparison_stream = ComparisonStream();
@@ -1143,6 +1488,7 @@ TEST(ManipulatorLogFormatTest, Oct) {
 
 TEST(ManipulatorLogFormatTest, Dec) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 77;
   auto comparison_stream = ComparisonStream();
@@ -1160,6 +1506,7 @@ TEST(ManipulatorLogFormatTest, Dec) {
 
 TEST(ManipulatorLogFormatTest, ShowbaseHex) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 0x77;
   auto comparison_stream = ComparisonStream();
@@ -1186,6 +1533,7 @@ TEST(ManipulatorLogFormatTest, ShowbaseHex) {
 
 TEST(ManipulatorLogFormatTest, ShowbaseOct) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 077;
   auto comparison_stream = ComparisonStream();
@@ -1211,6 +1559,7 @@ TEST(ManipulatorLogFormatTest, ShowbaseOct) {
 
 TEST(ManipulatorLogFormatTest, UppercaseHex) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 0xbeef;
   auto comparison_stream = ComparisonStream();
@@ -1238,6 +1587,7 @@ TEST(ManipulatorLogFormatTest, UppercaseHex) {
 
 TEST(ManipulatorLogFormatTest, FixedFloat) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 7.7e7;
   auto comparison_stream = ComparisonStream();
@@ -1255,6 +1605,7 @@ TEST(ManipulatorLogFormatTest, FixedFloat) {
 
 TEST(ManipulatorLogFormatTest, ScientificFloat) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 7.7e7;
   auto comparison_stream = ComparisonStream();
@@ -1278,6 +1629,7 @@ TEST(ManipulatorLogFormatTest, ScientificFloat) {
 #else
 TEST(ManipulatorLogFormatTest, FixedAndScientificFloat) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 7.7e7;
   auto comparison_stream = ComparisonStream();
@@ -1311,6 +1663,7 @@ TEST(ManipulatorLogFormatTest, FixedAndScientificFloat) {
 #else
 TEST(ManipulatorLogFormatTest, HexfloatFloat) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 7.7e7;
   auto comparison_stream = ComparisonStream();
@@ -1332,6 +1685,7 @@ TEST(ManipulatorLogFormatTest, HexfloatFloat) {
 
 TEST(ManipulatorLogFormatTest, DefaultFloatFloat) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 7.7e7;
   auto comparison_stream = ComparisonStream();
@@ -1349,6 +1703,7 @@ TEST(ManipulatorLogFormatTest, DefaultFloatFloat) {
 
 TEST(ManipulatorLogFormatTest, Ends) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   auto comparison_stream = ComparisonStream();
   comparison_stream << std::ends;
@@ -1365,6 +1720,7 @@ TEST(ManipulatorLogFormatTest, Ends) {
 
 TEST(ManipulatorLogFormatTest, Endl) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   auto comparison_stream = ComparisonStream();
   comparison_stream << std::endl;
@@ -1382,6 +1738,7 @@ TEST(ManipulatorLogFormatTest, Endl) {
 
 TEST(ManipulatorLogFormatTest, SetIosFlags) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 0x77;
   auto comparison_stream = ComparisonStream();
@@ -1411,6 +1768,7 @@ TEST(ManipulatorLogFormatTest, SetIosFlags) {
 
 TEST(ManipulatorLogFormatTest, SetBase) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 0x77;
   auto comparison_stream = ComparisonStream();
@@ -1435,6 +1793,7 @@ TEST(ManipulatorLogFormatTest, SetBase) {
 
 TEST(ManipulatorLogFormatTest, SetPrecision) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 6.022140857e23;
   auto comparison_stream = ComparisonStream();
@@ -1456,6 +1815,7 @@ TEST(ManipulatorLogFormatTest, SetPrecision) {
 
 TEST(ManipulatorLogFormatTest, SetPrecisionOverflow) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const double value = 6.022140857e23;
   auto comparison_stream = ComparisonStream();
@@ -1473,6 +1833,7 @@ TEST(ManipulatorLogFormatTest, SetPrecisionOverflow) {
 
 TEST(ManipulatorLogFormatTest, SetW) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 77;
   auto comparison_stream = ComparisonStream();
@@ -1494,6 +1855,7 @@ TEST(ManipulatorLogFormatTest, SetW) {
 
 TEST(ManipulatorLogFormatTest, Left) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = -77;
   auto comparison_stream = ComparisonStream();
@@ -1511,6 +1873,7 @@ TEST(ManipulatorLogFormatTest, Left) {
 
 TEST(ManipulatorLogFormatTest, Right) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = -77;
   auto comparison_stream = ComparisonStream();
@@ -1528,6 +1891,7 @@ TEST(ManipulatorLogFormatTest, Right) {
 
 TEST(ManipulatorLogFormatTest, Internal) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = -77;
   auto comparison_stream = ComparisonStream();
@@ -1545,6 +1909,7 @@ TEST(ManipulatorLogFormatTest, Internal) {
 
 TEST(ManipulatorLogFormatTest, SetFill) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int value = 77;
   auto comparison_stream = ComparisonStream();
@@ -1571,6 +1936,7 @@ std::ostream& operator<<(std::ostream& os, const FromCustomClass&) {
 
 TEST(ManipulatorLogFormatTest, FromCustom) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   FromCustomClass value;
   auto comparison_stream = ComparisonStream();
@@ -1593,6 +1959,7 @@ std::ostream& operator<<(std::ostream& os, const StreamsNothing&) { return os; }
 
 TEST(ManipulatorLogFormatTest, CustomClassStreamsNothing) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   StreamsNothing value;
   auto comparison_stream = ComparisonStream();
@@ -1620,6 +1987,7 @@ struct PointPercentV {
 
 TEST(ManipulatorLogFormatTest, IOManipsDoNotAffectAbslStringify) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   PointPercentV p;
 
@@ -1635,6 +2003,7 @@ TEST(ManipulatorLogFormatTest, IOManipsDoNotAffectAbslStringify) {
 
 TEST(StructuredLoggingOverflowTest, TruncatesStrings) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   // This message is too long and should be truncated to some unspecified size
   // no greater than the buffer size but not too much less either.  It should be
@@ -1655,6 +2024,30 @@ TEST(StructuredLoggingOverflowTest, TruncatesStrings) {
   LOG(INFO) << std::string(2 * absl::log_internal::kLogMessageBufferSize, 'x');
 }
 
+TEST(StructuredLoggingOverflowTest, TruncatesWideStrings) {
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  // This message is too long and should be truncated to some unspecified size
+  // no greater than the buffer size but not too much less either.  It should be
+  // truncated rather than discarded.
+  EXPECT_CALL(
+      test_sink,
+      Send(AllOf(
+          TextMessage(AllOf(
+              SizeIs(AllOf(Ge(absl::log_internal::kLogMessageBufferSize - 256),
+                           Le(absl::log_internal::kLogMessageBufferSize))),
+              Each(Eq('x')))),
+          ENCODED_MESSAGE(HasOneStrThat(AllOf(
+              SizeIs(AllOf(Ge(absl::log_internal::kLogMessageBufferSize - 256),
+                           Le(absl::log_internal::kLogMessageBufferSize))),
+              Each(Eq('x'))))))));
+
+  test_sink.StartCapturingLogs();
+  LOG(INFO) << std::wstring(2 * absl::log_internal::kLogMessageBufferSize,
+                            L'x');
+}
+
 struct StringLike {
   absl::string_view data;
 };
@@ -1664,6 +2057,7 @@ std::ostream& operator<<(std::ostream& os, StringLike str) {
 
 TEST(StructuredLoggingOverflowTest, TruncatesInsertionOperators) {
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   // This message is too long and should be truncated to some unspecified size
   // no greater than the buffer size but not too much less either.  It should be
@@ -1715,6 +2109,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesStringsCleanly) {
   // sizes.  To put any data in the field we need a fifth byte.
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrThat(
                                AllOf(SizeIs(longest_fit), Each(Eq('x'))))),
@@ -1725,6 +2120,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesStringsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrThat(
                                AllOf(SizeIs(longest_fit - 1), Each(Eq('x'))))),
@@ -1735,6 +2131,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesStringsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrThat(
                                AllOf(SizeIs(longest_fit - 2), Each(Eq('x'))))),
@@ -1745,6 +2142,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesStringsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrThat(
                                AllOf(SizeIs(longest_fit - 3), Each(Eq('x'))))),
@@ -1755,6 +2153,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesStringsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrAndOneLiteralThat(
                                AllOf(SizeIs(longest_fit - 4), Each(Eq('x'))),
@@ -1767,6 +2166,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesStringsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(
         test_sink,
         Send(AllOf(ENCODED_MESSAGE(HasOneStrAndOneLiteralThat(
@@ -1784,6 +2184,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesInsertionOperatorsCleanly) {
   // sizes.  To put any data in the field we need a fifth byte.
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrThat(
                                AllOf(SizeIs(longest_fit), Each(Eq('x'))))),
@@ -1794,6 +2195,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesInsertionOperatorsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrThat(
                                AllOf(SizeIs(longest_fit - 1), Each(Eq('x'))))),
@@ -1805,6 +2207,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesInsertionOperatorsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrThat(
                                AllOf(SizeIs(longest_fit - 2), Each(Eq('x'))))),
@@ -1816,6 +2219,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesInsertionOperatorsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrThat(
                                AllOf(SizeIs(longest_fit - 3), Each(Eq('x'))))),
@@ -1827,6 +2231,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesInsertionOperatorsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(test_sink,
                 Send(AllOf(ENCODED_MESSAGE(HasOneStrThat(
                                AllOf(SizeIs(longest_fit - 4), Each(Eq('x'))))),
@@ -1840,6 +2245,7 @@ TEST(StructuredLoggingOverflowTest, TruncatesInsertionOperatorsCleanly) {
   }
   {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
     EXPECT_CALL(
         test_sink,
         Send(AllOf(ENCODED_MESSAGE(HasTwoStrsThat(