@nxtedition/rocksdb 15.2.2 → 15.2.4

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

@@ -1,2261 +0,0 @@
-//
-// Copyright 2022 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#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__
-#include <android/api-level.h>
-#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"
-#include "absl/log/scoped_mock_log.h"
-#include "absl/strings/match.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-
-namespace {
-using ::absl::log_internal::AsString;
-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;
-using ::testing::EndsWith;
-using ::testing::Eq;
-using ::testing::Ge;
-using ::testing::IsEmpty;
-using ::testing::Le;
-using ::testing::SizeIs;
-using ::testing::Types;
-
-// Some aspects of formatting streamed data (e.g. pointer handling) are
-// implementation-defined.  Others are buggy in supported implementations.
-// These tests validate that the formatting matches that performed by a
-// `std::ostream` and also that the result is one of a list of expected formats.
-
-std::ostringstream ComparisonStream() {
-  std::ostringstream str;
-  str.setf(std::ios_base::showbase | std::ios_base::boolalpha |
-           std::ios_base::internal);
-  return str;
-}
-
-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); };
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(ComparisonStream())),
-                         TextPrefix(AsString(EndsWith(absl::StrCat(
-                             " log_format_test.cc:", log_line, "] ")))),
-                         TextMessage(IsEmpty()),
-                         ENCODED_MESSAGE(HasValues(IsEmpty())))));
-
-  test_sink.StartCapturingLogs();
-  do_log();
-}
-
-template <typename T>
-class CharLogFormatTest : public testing::Test {};
-using CharTypes = Types<char, signed char, unsigned char>;
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)), TextMessage(Eq("x")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("x"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("\xee")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("\xee"))))))));
-
-  test_sink.StartCapturingLogs();
-  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
-                               unsigned long, unsigned long long>;  // NOLINT
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("224")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("224"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-TYPED_TEST(UnsignedIntLogFormatTest, BitfieldPositive) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  const struct {
-    TypeParam bits : 6;
-  } value{42};
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value.bits;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)), TextMessage(Eq("42")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("42"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value.bits;
-}
-
-template <typename T>
-class SignedIntLogFormatTest : public testing::Test {};
-using SignedIntTypes =
-    Types<signed short, signed int, signed long, signed long long>;  // NOLINT
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("224")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("224"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("-112")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("-112"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-TYPED_TEST(SignedIntLogFormatTest, BitfieldPositive) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  const struct {
-    TypeParam bits : 6;
-  } value{21};
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value.bits;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)), TextMessage(Eq("21")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("21"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value.bits;
-}
-
-TYPED_TEST(SignedIntLogFormatTest, BitfieldNegative) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  const struct {
-    TypeParam bits : 6;
-  } value{-21};
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value.bits;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("-21")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("-21"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value.bits;
-}
-
-// Ignore these test cases on GCC due to "is too small to hold all values ..."
-// warning.
-#if !defined(__GNUC__) || defined(__clang__)
-// The implementation may choose a signed or unsigned integer type to represent
-// this enum, so it may be tested by either `UnsignedEnumLogFormatTest` or
-// `SignedEnumLogFormatTest`.
-enum MyUnsignedEnum {
-  MyUnsignedEnum_ZERO = 0,
-  MyUnsignedEnum_FORTY_TWO = 42,
-  MyUnsignedEnum_TWO_HUNDRED_TWENTY_FOUR = 224,
-};
-enum MyUnsignedIntEnum : unsigned int {
-  MyUnsignedIntEnum_ZERO = 0,
-  MyUnsignedIntEnum_FORTY_TWO = 42,
-  MyUnsignedIntEnum_TWO_HUNDRED_TWENTY_FOUR = 224,
-};
-
-template <typename T>
-class UnsignedEnumLogFormatTest : public testing::Test {};
-using UnsignedEnumTypes = std::conditional<
-    std::is_signed<std::underlying_type<MyUnsignedEnum>::type>::value,
-    Types<MyUnsignedIntEnum>, Types<MyUnsignedEnum, MyUnsignedIntEnum>>::type;
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("224")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("224"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-TYPED_TEST(UnsignedEnumLogFormatTest, BitfieldPositive) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  const struct {
-    TypeParam bits : 6;
-  } value{static_cast<TypeParam>(42)};
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value.bits;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)), TextMessage(Eq("42")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("42"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value.bits;
-}
-
-enum MySignedEnum {
-  MySignedEnum_NEGATIVE_ONE_HUNDRED_TWELVE = -112,
-  MySignedEnum_NEGATIVE_TWENTY_ONE = -21,
-  MySignedEnum_ZERO = 0,
-  MySignedEnum_TWENTY_ONE = 21,
-  MySignedEnum_TWO_HUNDRED_TWENTY_FOUR = 224,
-};
-enum MySignedIntEnum : signed int {
-  MySignedIntEnum_NEGATIVE_ONE_HUNDRED_TWELVE = -112,
-  MySignedIntEnum_NEGATIVE_TWENTY_ONE = -21,
-  MySignedIntEnum_ZERO = 0,
-  MySignedIntEnum_TWENTY_ONE = 21,
-  MySignedIntEnum_TWO_HUNDRED_TWENTY_FOUR = 224,
-};
-
-template <typename T>
-class SignedEnumLogFormatTest : public testing::Test {};
-using SignedEnumTypes = std::conditional<
-    std::is_signed<std::underlying_type<MyUnsignedEnum>::type>::value,
-    Types<MyUnsignedEnum, MySignedEnum, MySignedIntEnum>,
-    Types<MySignedEnum, MySignedIntEnum>>::type;
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("224")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("224"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("-112")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("-112"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-TYPED_TEST(SignedEnumLogFormatTest, BitfieldPositive) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  const struct {
-    TypeParam bits : 6;
-  } value{static_cast<TypeParam>(21)};
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value.bits;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)), TextMessage(Eq("21")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("21"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value.bits;
-}
-
-TYPED_TEST(SignedEnumLogFormatTest, BitfieldNegative) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  const struct {
-    TypeParam bits : 6;
-  } value{static_cast<TypeParam>(-21)};
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value.bits;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("-21")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("-21"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value.bits;
-}
-#endif
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("6.02e+23")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("6.02e+23"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("-6.02e+23")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("-6.02e+23"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("6.02e-23")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("6.02e-23"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("6.02e+23")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("6.02e+23"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("-6.02e+23")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("-6.02e+23"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("6.02e-23")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("6.02e-23"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-template <typename T>
-class FloatingPointLogFormatTest : public testing::Test {};
-using FloatingPointTypes = Types<float, double>;
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)), TextMessage(Eq("0")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("0"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)), TextMessage(Eq("1")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("1"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(AnyOf(Eq("inf"), Eq("Inf"))),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("inf"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(AnyOf(Eq("-inf"), Eq("-Inf"))),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("-inf"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(AnyOf(Eq("nan"), Eq("NaN"))),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("nan"))))))));
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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);
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value;
-
-  // On RISC-V, don't expect that formatting -NaN produces the same string as
-  // streaming it. #ifdefing out just the relevant line breaks the MSVC build,
-  // so duplicate the entire EXPECT_CALL.
-#ifdef __riscv
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(AnyOf(Eq("-nan"), Eq("nan"), Eq("NaN"),
-                                           Eq("-nan(ind)"))),
-                         ENCODED_MESSAGE(HasValues(ElementsAre(AnyOf(
-                             ValueWithStr(Eq("-nan")), ValueWithStr(Eq("nan")),
-                             ValueWithStr(Eq("-nan(ind)")))))))));
-#else
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(AnyOf(Eq("-nan"), Eq("nan"), Eq("NaN"),
-                                           Eq("-nan(ind)"))),
-                         ENCODED_MESSAGE(HasValues(ElementsAre(AnyOf(
-                             ValueWithStr(Eq("-nan")), ValueWithStr(Eq("nan")),
-                             ValueWithStr(Eq("-nan(ind)")))))))));
-#endif
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-template <typename T>
-class VoidPtrLogFormatTest : public testing::Test {};
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(AnyOf(Eq("(nil)"), Eq("0"), Eq("0x0"),
-                                   Eq("00000000"), Eq("0000000000000000"))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  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")))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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*, 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;
-}
-
-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;
-}
-
-template <typename T>
-class CharPtrLogFormatTest : public testing::Test {};
-using CharPtrTypes = Types<char, const char, signed char, const signed char,
-                           unsigned char, const unsigned char>;
-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
-  // something useful instead of crashing, even when that differs from the
-  // standard library in use (and thus the behavior of `std::ostream`).
-  TypeParam* const value = nullptr;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          // `MatchesOstream` deliberately omitted since we deliberately differ.
-          TextMessage(Eq("(null)")), ENCODED_MESSAGE(HasValues(ElementsAre(
-                                         ValueWithStr(Eq("(null)"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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;
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("value")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("value"))))))));
-
-  test_sink.StartCapturingLogs();
-  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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("true")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("true"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("false")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("false"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-TEST(LogFormatTest, StringLiteral) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << "value";
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("value")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithLiteral(Eq("value"))))))));
-
-  test_sink.StartCapturingLogs();
-  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();
-  comparison_stream << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("value")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("value"))))))));
-
-  test_sink.StartCapturingLogs();
-  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{}";
-}
-
-TEST(LogFormatTest, Custom) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  CustomClass value;
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("CustomClass{}")),
-                         ENCODED_MESSAGE(HasValues(ElementsAre(
-                             ValueWithStr(Eq("CustomClass{}"))))))));
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-class CustomClassNonCopyable {
- public:
-  CustomClassNonCopyable() = default;
-  CustomClassNonCopyable(const CustomClassNonCopyable&) = delete;
-  CustomClassNonCopyable& operator=(const CustomClassNonCopyable&) = delete;
-};
-std::ostream& operator<<(std::ostream& os, const CustomClassNonCopyable&) {
-  return os << "CustomClassNonCopyable{}";
-}
-
-TEST(LogFormatTest, CustomNonCopyable) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  CustomClassNonCopyable value;
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("CustomClassNonCopyable{}")),
-                         ENCODED_MESSAGE(HasValues(ElementsAre(
-                             ValueWithStr(Eq("CustomClassNonCopyable{}"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value;
-}
-
-struct Point {
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, const Point& p) {
-    absl::Format(&sink, "(%d, %d)", p.x, p.y);
-  }
-
-  int x = 10;
-  int y = 20;
-};
-
-TEST(LogFormatTest, AbslStringifyExample) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  Point p;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(Eq("(10, 20)")), TextMessage(Eq(absl::StrCat(p))),
-                 ENCODED_MESSAGE(
-                     HasValues(ElementsAre(ValueWithStr(Eq("(10, 20)"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << p;
-}
-
-struct PointWithAbslStringifiyAndOstream {
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink,
-                            const PointWithAbslStringifiyAndOstream& p) {
-    absl::Format(&sink, "(%d, %d)", p.x, p.y);
-  }
-
-  int x = 10;
-  int y = 20;
-};
-
-ABSL_ATTRIBUTE_UNUSED std::ostream& operator<<(
-    std::ostream& os, const PointWithAbslStringifiyAndOstream&) {
-  return os << "Default to AbslStringify()";
-}
-
-TEST(LogFormatTest, CustomWithAbslStringifyAndOstream) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  PointWithAbslStringifiyAndOstream p;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(Eq("(10, 20)")), TextMessage(Eq(absl::StrCat(p))),
-                 ENCODED_MESSAGE(
-                     HasValues(ElementsAre(ValueWithStr(Eq("(10, 20)"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << p;
-}
-
-struct PointStreamsNothing {
-  template <typename Sink>
-  friend void AbslStringify(Sink&, const PointStreamsNothing&) {}
-
-  int x = 10;
-  int y = 20;
-};
-
-TEST(LogFormatTest, AbslStringifyStreamsNothing) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  PointStreamsNothing p;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(Eq("77")), TextMessage(Eq(absl::StrCat(p, 77))),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << p << 77;
-}
-
-struct PointMultipleAppend {
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, const PointMultipleAppend& p) {
-    sink.Append("(");
-    sink.Append(absl::StrCat(p.x, ", ", p.y, ")"));
-  }
-
-  int x = 10;
-  int y = 20;
-};
-
-TEST(LogFormatTest, AbslStringifyMultipleAppend) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  PointMultipleAppend p;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(Eq("(10, 20)")), TextMessage(Eq(absl::StrCat(p))),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     ValueWithStr(Eq("(")), ValueWithStr(Eq("10, 20)"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << p;
-}
-
-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();
-  comparison_stream << std::noboolalpha << value << " "  //
-                    << std::boolalpha << value << " "    //
-                    << std::noboolalpha << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("1 true 1")),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     ValueWithStr(Eq("1")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("true")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("1"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::noboolalpha << value << " "  //
-            << std::boolalpha << value << " "    //
-            << std::noboolalpha << value;
-}
-
-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();
-  comparison_stream << std::noboolalpha << value << " "  //
-                    << std::boolalpha << value << " "    //
-                    << std::noboolalpha << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("0 false 0")),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     ValueWithStr(Eq("0")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("false")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("0"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::noboolalpha << value << " "  //
-            << std::boolalpha << value << " "    //
-            << std::noboolalpha << value;
-}
-
-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();
-  comparison_stream << std::noshowpoint << value << " "  //
-                    << std::showpoint << value << " "    //
-                    << std::noshowpoint << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("77 77.0000 77")),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     ValueWithStr(Eq("77")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("77.0000")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::noshowpoint << value << " "  //
-            << std::showpoint << value << " "    //
-            << std::noshowpoint << value;
-}
-
-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();
-  comparison_stream << std::noshowpos << value << " "  //
-                    << std::showpos << value << " "    //
-                    << std::noshowpos << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("77 +77 77")),
-                         ENCODED_MESSAGE(HasValues(ElementsAre(
-                             ValueWithStr(Eq("77")), ValueWithLiteral(Eq(" ")),
-                             ValueWithStr(Eq("+77")), ValueWithLiteral(Eq(" ")),
-                             ValueWithStr(Eq("77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::noshowpos << value << " "  //
-            << std::showpos << value << " "    //
-            << std::noshowpos << value;
-}
-
-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();
-  comparison_stream << std::nouppercase << value << " "  //
-                    << std::uppercase << value << " "    //
-                    << std::nouppercase << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("7.7e+07 7.7E+07 7.7e+07")),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     ValueWithStr(Eq("7.7e+07")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("7.7E+07")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("7.7e+07"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::nouppercase << value << " "  //
-            << std::uppercase << value << " "    //
-            << std::nouppercase << value;
-}
-
-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();
-  comparison_stream << std::hex << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("0x77")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("0x77"))))))));
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::hex << value;
-}
-
-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();
-  comparison_stream << std::oct << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("077")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("077"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::oct << value;
-}
-
-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();
-  comparison_stream << std::hex << std::dec << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)), TextMessage(Eq("77")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::hex << std::dec << value;
-}
-
-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();
-  comparison_stream << std::hex                         //
-                    << std::noshowbase << value << " "  //
-                    << std::showbase << value << " "    //
-                    << std::noshowbase << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("77 0x77 77")),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     ValueWithStr(Eq("77")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("0x77")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::hex                         //
-            << std::noshowbase << value << " "  //
-            << std::showbase << value << " "    //
-            << std::noshowbase << value;
-}
-
-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();
-  comparison_stream << std::oct                         //
-                    << std::noshowbase << value << " "  //
-                    << std::showbase << value << " "    //
-                    << std::noshowbase << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("77 077 77")),
-                         ENCODED_MESSAGE(HasValues(ElementsAre(
-                             ValueWithStr(Eq("77")), ValueWithLiteral(Eq(" ")),
-                             ValueWithStr(Eq("077")), ValueWithLiteral(Eq(" ")),
-                             ValueWithStr(Eq("77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::oct                         //
-            << std::noshowbase << value << " "  //
-            << std::showbase << value << " "    //
-            << std::noshowbase << value;
-}
-
-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();
-  comparison_stream                        //
-      << std::hex                          //
-      << std::nouppercase << value << " "  //
-      << std::uppercase << value << " "    //
-      << std::nouppercase << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("0xbeef 0XBEEF 0xbeef")),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     ValueWithStr(Eq("0xbeef")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("0XBEEF")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("0xbeef"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::hex                          //
-            << std::nouppercase << value << " "  //
-            << std::uppercase << value << " "    //
-            << std::nouppercase << value;
-}
-
-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();
-  comparison_stream << std::fixed << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("77000000.000000")),
-                         ENCODED_MESSAGE(HasValues(ElementsAre(
-                             ValueWithStr(Eq("77000000.000000"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::fixed << value;
-}
-
-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();
-  comparison_stream << std::scientific << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("7.700000e+07")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("7.700000e+07"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::scientific << value;
-}
-
-#if defined(__BIONIC__) && (!defined(__ANDROID_API__) || __ANDROID_API__ < 22)
-// Bionic doesn't support `%a` until API 22, so this prints 'a' even if the
-// C++ standard library implements it correctly (by forwarding to printf).
-#elif defined(__GLIBCXX__) && __cplusplus < 201402L
-// libstdc++ shipped C++11 support without `std::hexfloat`.
-#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();
-  comparison_stream << std::setiosflags(std::ios_base::scientific |
-                                        std::ios_base::fixed)
-                    << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(AnyOf(Eq("0x1.25bb50p+26"), Eq("0x1.25bb5p+26"),
-                                   Eq("0x1.25bb500000000p+26"))),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     AnyOf(ValueWithStr(Eq("0x1.25bb5p+26")),
-                           ValueWithStr(Eq("0x1.25bb500000000p+26")))))))));
-
-  test_sink.StartCapturingLogs();
-
-  // This combination should mean the same thing as `std::hexfloat`.
-  LOG(INFO) << std::setiosflags(std::ios_base::scientific |
-                                std::ios_base::fixed)
-            << value;
-}
-#endif
-
-#if defined(__BIONIC__) && (!defined(__ANDROID_API__) || __ANDROID_API__ < 22)
-// Bionic doesn't support `%a` until API 22, so this prints 'a' even if the C++
-// standard library supports `std::hexfloat` (by forwarding to printf).
-#elif defined(__GLIBCXX__) && __cplusplus < 201402L
-// libstdc++ shipped C++11 support without `std::hexfloat`.
-#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();
-  comparison_stream << std::hexfloat << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(AnyOf(Eq("0x1.25bb50p+26"), Eq("0x1.25bb5p+26"),
-                                   Eq("0x1.25bb500000000p+26"))),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     AnyOf(ValueWithStr(Eq("0x1.25bb5p+26")),
-                           ValueWithStr(Eq("0x1.25bb500000000p+26")))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::hexfloat << value;
-}
-#endif
-
-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();
-  comparison_stream << std::hexfloat << std::defaultfloat << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("7.7e+07")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("7.7e+07"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::hexfloat << std::defaultfloat << value;
-}
-
-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;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq(absl::string_view("\0", 1))),
-                         ENCODED_MESSAGE(HasValues(ElementsAre(
-                             ValueWithStr(Eq(absl::string_view("\0", 1)))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::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;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("\n")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("\n"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::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();
-  comparison_stream << std::resetiosflags(std::ios_base::basefield)
-                    << std::setiosflags(std::ios_base::hex) << value << " "  //
-                    << std::resetiosflags(std::ios_base::basefield)
-                    << std::setiosflags(std::ios_base::dec) << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)),
-          TextMessage(Eq("0x77 119")),
-          // `std::setiosflags` and `std::resetiosflags` aren't manipulators.
-          // We're unable to distinguish their return type(s) from arbitrary
-          // user-defined types and thus don't suppress the empty str value.
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("0x77")),
-                                                ValueWithLiteral(Eq(" ")),
-                                                ValueWithStr(Eq("119"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::resetiosflags(std::ios_base::basefield)
-            << std::setiosflags(std::ios_base::hex) << value << " "  //
-            << std::resetiosflags(std::ios_base::basefield)
-            << std::setiosflags(std::ios_base::dec) << value;
-}
-
-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();
-  comparison_stream << std::setbase(16) << value << " "  //
-                    << std::setbase(0) << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("0x77 119")),
-                 // `std::setbase` isn't a manipulator.  We're unable to
-                 // distinguish its return type from arbitrary user-defined
-                 // types and thus don't suppress the empty str value.
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     ValueWithStr(Eq("0x77")), ValueWithLiteral(Eq(" ")),
-                     ValueWithStr(Eq("119"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::setbase(16) << value << " "  //
-            << std::setbase(0) << value;
-}
-
-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();
-  comparison_stream << std::setprecision(4) << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("6.022e+23")),
-                 // `std::setprecision` isn't a manipulator.  We're unable to
-                 // distinguish its return type from arbitrary user-defined
-                 // types and thus don't suppress the empty str value.
-                 ENCODED_MESSAGE(
-                     HasValues(ElementsAre(ValueWithStr(Eq("6.022e+23"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::setprecision(4) << value;
-}
-
-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();
-  comparison_stream << std::setprecision(200) << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("602214085700000015187968")),
-                         ENCODED_MESSAGE(HasValues(ElementsAre(
-                             ValueWithStr(Eq("602214085700000015187968"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::setprecision(200) << value;
-}
-
-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();
-  comparison_stream << std::setw(8) << value;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("      77")),
-                 // `std::setw` isn't a manipulator.  We're unable to
-                 // distinguish its return type from arbitrary user-defined
-                 // types and thus don't suppress the empty str value.
-                 ENCODED_MESSAGE(
-                     HasValues(ElementsAre(ValueWithStr(Eq("      77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::setw(8) << value;
-}
-
-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();
-  comparison_stream << std::left << std::setw(8) << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("-77     ")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("-77     "))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::left << std::setw(8) << value;
-}
-
-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();
-  comparison_stream << std::right << std::setw(8) << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("     -77")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("     -77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::right << std::setw(8) << value;
-}
-
-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();
-  comparison_stream << std::internal << std::setw(8) << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("-     77")),
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("-     77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::internal << std::setw(8) << value;
-}
-
-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();
-  comparison_stream << std::setfill('0') << std::setw(8) << value;
-
-  EXPECT_CALL(test_sink,
-              Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                         TextMessage(Eq("00000077")),
-                         // `std::setfill` isn't a manipulator.  We're
-                         // unable to distinguish its return
-                         // type from arbitrary user-defined types and
-                         // thus don't suppress the empty str value.
-                         ENCODED_MESSAGE(HasValues(
-                             ElementsAre(ValueWithStr(Eq("00000077"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::setfill('0') << std::setw(8) << value;
-}
-
-class FromCustomClass {};
-std::ostream& operator<<(std::ostream& os, const FromCustomClass&) {
-  return os << "FromCustomClass{}" << std::hex;
-}
-
-TEST(ManipulatorLogFormatTest, FromCustom) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  FromCustomClass value;
-  auto comparison_stream = ComparisonStream();
-  comparison_stream << value << " " << 0x77;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(MatchesOstream(comparison_stream)),
-                 TextMessage(Eq("FromCustomClass{} 0x77")),
-                 ENCODED_MESSAGE(HasValues(ElementsAre(
-                     ValueWithStr(Eq("FromCustomClass{}")),
-                     ValueWithLiteral(Eq(" ")), ValueWithStr(Eq("0x77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value << " " << 0x77;
-}
-
-class StreamsNothing {};
-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();
-  comparison_stream << value << 77;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(
-          TextMessage(MatchesOstream(comparison_stream)), TextMessage(Eq("77")),
-          ENCODED_MESSAGE(HasValues(ElementsAre(ValueWithStr(Eq("77"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << value << 77;
-}
-
-struct PointPercentV {
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, const PointPercentV& p) {
-    absl::Format(&sink, "(%v, %v)", p.x, p.y);
-  }
-
-  int x = 10;
-  int y = 20;
-};
-
-TEST(ManipulatorLogFormatTest, IOManipsDoNotAffectAbslStringify) {
-  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-  EXPECT_CALL(test_sink, Send).Times(0);
-
-  PointPercentV p;
-
-  EXPECT_CALL(
-      test_sink,
-      Send(AllOf(TextMessage(Eq("(10, 20)")), TextMessage(Eq(absl::StrCat(p))),
-                 ENCODED_MESSAGE(
-                     HasValues(ElementsAre(ValueWithStr(Eq("(10, 20)"))))))));
-
-  test_sink.StartCapturingLogs();
-  LOG(INFO) << std::hex << p;
-}
-
-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
-  // 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::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;
-};
-std::ostream& operator<<(std::ostream& os, StringLike str) {
-  return os << str.data;
-}
-
-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
-  // 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) << StringLike{
-      std::string(2 * absl::log_internal::kLogMessageBufferSize, 'x')};
-}
-
-// Returns the size of the largest string that will fit in a `LOG` message
-// buffer with no prefix.
-size_t MaxLogFieldLengthNoPrefix() {
-  class StringLengthExtractorSink : public absl::LogSink {
-   public:
-    void Send(const absl::LogEntry& entry) override {
-      CHECK(!size_.has_value());
-      CHECK_EQ(entry.text_message().find_first_not_of('x'),
-               absl::string_view::npos);
-      size_.emplace(entry.text_message().size());
-    }
-    size_t size() const {
-      CHECK(size_.has_value());
-      return *size_;
-    }
-
-   private:
-    absl::optional<size_t> size_;
-  } extractor_sink;
-  LOG(INFO).NoPrefix().ToSinkOnly(&extractor_sink)
-      << std::string(2 * absl::log_internal::kLogMessageBufferSize, 'x');
-  return extractor_sink.size();
-}
-
-TEST(StructuredLoggingOverflowTest, TruncatesStringsCleanly) {
-  const size_t longest_fit = MaxLogFieldLengthNoPrefix();
-  // To log a second value field, we need four bytes: two tag/type bytes and two
-  // 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'))))),
-                           RawEncodedMessage(AsString(EndsWith("x"))))));
-    test_sink.StartCapturingLogs();
-    // x fits exactly, no part of y fits.
-    LOG(INFO).NoPrefix() << std::string(longest_fit, 'x') << "y";
-  }
-  {
-    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'))))),
-                           RawEncodedMessage(AsString(EndsWith("x"))))));
-    test_sink.StartCapturingLogs();
-    // x fits, one byte from y's header fits but shouldn't be visible.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 1, 'x') << "y";
-  }
-  {
-    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'))))),
-                           RawEncodedMessage(AsString(EndsWith("x"))))));
-    test_sink.StartCapturingLogs();
-    // x fits, two bytes from y's header fit but shouldn't be visible.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 2, 'x') << "y";
-  }
-  {
-    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'))))),
-                           RawEncodedMessage(AsString(EndsWith("x"))))));
-    test_sink.StartCapturingLogs();
-    // x fits, three bytes from y's header fit but shouldn't be visible.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 3, 'x') << "y";
-  }
-  {
-    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'))),
-                               IsEmpty())),
-                           RawEncodedMessage(Not(AsString(EndsWith("x")))))));
-    test_sink.StartCapturingLogs();
-    // x fits, all four bytes from y's header fit but no data bytes do, so we
-    // encode an empty string.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 4, 'x') << "y";
-  }
-  {
-    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 - 5), Each(Eq('x'))), Eq("y"))),
-                   RawEncodedMessage(AsString(EndsWith("y"))))));
-    test_sink.StartCapturingLogs();
-    // x fits, y fits exactly.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 5, 'x') << "y";
-  }
-}
-
-TEST(StructuredLoggingOverflowTest, TruncatesInsertionOperatorsCleanly) {
-  const size_t longest_fit = MaxLogFieldLengthNoPrefix();
-  // To log a second value field, we need four bytes: two tag/type bytes and two
-  // 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'))))),
-                           RawEncodedMessage(AsString(EndsWith("x"))))));
-    test_sink.StartCapturingLogs();
-    // x fits exactly, no part of y fits.
-    LOG(INFO).NoPrefix() << std::string(longest_fit, 'x') << StringLike{"y"};
-  }
-  {
-    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'))))),
-                           RawEncodedMessage(AsString(EndsWith("x"))))));
-    test_sink.StartCapturingLogs();
-    // x fits, one byte from y's header fits but shouldn't be visible.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 1, 'x')
-                         << StringLike{"y"};
-  }
-  {
-    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'))))),
-                           RawEncodedMessage(AsString(EndsWith("x"))))));
-    test_sink.StartCapturingLogs();
-    // x fits, two bytes from y's header fit but shouldn't be visible.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 2, 'x')
-                         << StringLike{"y"};
-  }
-  {
-    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'))))),
-                           RawEncodedMessage(AsString(EndsWith("x"))))));
-    test_sink.StartCapturingLogs();
-    // x fits, three bytes from y's header fit but shouldn't be visible.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 3, 'x')
-                         << StringLike{"y"};
-  }
-  {
-    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'))))),
-                           RawEncodedMessage(AsString(EndsWith("x"))))));
-    test_sink.StartCapturingLogs();
-    // x fits, all four bytes from y's header fit but no data bytes do.  We
-    // don't encode an empty string here because every I/O manipulator hits this
-    // codepath and those shouldn't leave empty strings behind.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 4, 'x')
-                         << StringLike{"y"};
-  }
-  {
-    absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
-    EXPECT_CALL(test_sink, Send).Times(0);
-    EXPECT_CALL(
-        test_sink,
-        Send(AllOf(ENCODED_MESSAGE(HasTwoStrsThat(
-                       AllOf(SizeIs(longest_fit - 5), Each(Eq('x'))), Eq("y"))),
-                   RawEncodedMessage(AsString(EndsWith("y"))))));
-    test_sink.StartCapturingLogs();
-    // x fits, y fits exactly.
-    LOG(INFO).NoPrefix() << std::string(longest_fit - 5, 'x')
-                         << StringLike{"y"};
-  }
-}
-
-}  // namespace