@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/log/internal/strip.h

@@ -1,99 +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.
-//
-// -----------------------------------------------------------------------------
-// File: log/internal/strip.h
-// -----------------------------------------------------------------------------
-
-// SKIP_ABSL_INLINE_NAMESPACE_CHECK
-
-#ifndef ABSL_LOG_INTERNAL_STRIP_H_
-#define ABSL_LOG_INTERNAL_STRIP_H_
-
-#include "absl/base/attributes.h"  // IWYU pragma: keep
-#include "absl/base/log_severity.h"
-#include "absl/log/internal/log_message.h"
-#include "absl/log/internal/nullstream.h"
-
-// `ABSL_LOG_INTERNAL_LOG_*` evaluates to a temporary `LogMessage` object or
-// to a related object with a compatible API but different behavior.  This set
-// of defines comes in three flavors: vanilla, plus two variants that strip some
-// logging in subtly different ways for subtly different reasons (see below).
-#if defined(STRIP_LOG) && STRIP_LOG
-
-#define ABSL_LOG_INTERNAL_LOG_INFO ::absl::log_internal::NullStream()
-#define ABSL_LOG_INTERNAL_LOG_WARNING ::absl::log_internal::NullStream()
-#define ABSL_LOG_INTERNAL_LOG_ERROR ::absl::log_internal::NullStream()
-#define ABSL_LOG_INTERNAL_LOG_FATAL ::absl::log_internal::NullStreamFatal()
-#define ABSL_LOG_INTERNAL_LOG_QFATAL ::absl::log_internal::NullStreamFatal()
-#define ABSL_LOG_INTERNAL_LOG_DFATAL \
-  ::absl::log_internal::NullStreamMaybeFatal(::absl::kLogDebugFatal)
-#define ABSL_LOG_INTERNAL_LOG_LEVEL(severity) \
-  ::absl::log_internal::NullStreamMaybeFatal(absl_log_internal_severity)
-
-// Fatal `DLOG`s expand a little differently to avoid being `[[noreturn]]`.
-#define ABSL_LOG_INTERNAL_DLOG_FATAL \
-  ::absl::log_internal::NullStreamMaybeFatal(::absl::LogSeverity::kFatal)
-#define ABSL_LOG_INTERNAL_DLOG_QFATAL \
-  ::absl::log_internal::NullStreamMaybeFatal(::absl::LogSeverity::kFatal)
-
-#define ABSL_LOG_INTERNAL_CHECK(failure_message) ABSL_LOG_INTERNAL_LOG_FATAL
-#define ABSL_LOG_INTERNAL_QCHECK(failure_message) ABSL_LOG_INTERNAL_LOG_QFATAL
-
-#else  // !defined(STRIP_LOG) || !STRIP_LOG
-
-#define ABSL_LOG_INTERNAL_LOG_INFO  \
-  ::absl::log_internal::LogMessage( \
-      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
-#define ABSL_LOG_INTERNAL_LOG_WARNING \
-  ::absl::log_internal::LogMessage(   \
-      __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{})
-#define ABSL_LOG_INTERNAL_LOG_ERROR \
-  ::absl::log_internal::LogMessage( \
-      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
-#define ABSL_LOG_INTERNAL_LOG_FATAL \
-  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__)
-#define ABSL_LOG_INTERNAL_LOG_QFATAL \
-  ::absl::log_internal::LogMessageQuietlyFatal(__FILE__, __LINE__)
-#define ABSL_LOG_INTERNAL_LOG_DFATAL \
-  ::absl::log_internal::LogMessage(__FILE__, __LINE__, ::absl::kLogDebugFatal)
-#define ABSL_LOG_INTERNAL_LOG_LEVEL(severity)          \
-  ::absl::log_internal::LogMessage(__FILE__, __LINE__, \
-                                   absl_log_internal_severity)
-
-// Fatal `DLOG`s expand a little differently to avoid being `[[noreturn]]`.
-#define ABSL_LOG_INTERNAL_DLOG_FATAL \
-  ::absl::log_internal::LogMessageDebugFatal(__FILE__, __LINE__)
-#define ABSL_LOG_INTERNAL_DLOG_QFATAL \
-  ::absl::log_internal::LogMessageQuietlyDebugFatal(__FILE__, __LINE__)
-
-// These special cases dispatch to special-case constructors that allow us to
-// avoid an extra function call and shrink non-LTO binaries by a percent or so.
-#define ABSL_LOG_INTERNAL_CHECK(failure_message) \
-  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
-#define ABSL_LOG_INTERNAL_QCHECK(failure_message)                  \
-  ::absl::log_internal::LogMessageQuietlyFatal(__FILE__, __LINE__, \
-                                               failure_message)
-#endif  // !defined(STRIP_LOG) || !STRIP_LOG
-
-// This part of a non-fatal `DLOG`s expands the same as `LOG`.
-#define ABSL_LOG_INTERNAL_DLOG_INFO ABSL_LOG_INTERNAL_LOG_INFO
-#define ABSL_LOG_INTERNAL_DLOG_WARNING ABSL_LOG_INTERNAL_LOG_WARNING
-#define ABSL_LOG_INTERNAL_DLOG_ERROR ABSL_LOG_INTERNAL_LOG_ERROR
-#define ABSL_LOG_INTERNAL_DLOG_DFATAL ABSL_LOG_INTERNAL_LOG_DFATAL
-#define ABSL_LOG_INTERNAL_DLOG_LEVEL ABSL_LOG_INTERNAL_LOG_LEVEL
-
-#define ABSL_LOG_INTERNAL_LOG_DO_NOT_SUBMIT ABSL_LOG_INTERNAL_LOG_ERROR
-
-#endif  // ABSL_LOG_INTERNAL_STRIP_H_

package/deps/abseil-cpp/absl/log/internal/structured.h

@@ -1,160 +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.
-//
-// -----------------------------------------------------------------------------
-// File: log/internal/structured.h
-// -----------------------------------------------------------------------------
-
-#ifndef ABSL_LOG_INTERNAL_STRUCTURED_H_
-#define ABSL_LOG_INTERNAL_STRUCTURED_H_
-
-#include <ostream>
-#include <string>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/functional/any_invocable.h"
-#include "absl/log/internal/log_message.h"
-#include "absl/log/internal/structured_proto.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace log_internal {
-
-class [[nodiscard]] AsLiteralImpl final {
- public:
-  explicit AsLiteralImpl(absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : str_(str) {}
-  AsLiteralImpl(const AsLiteralImpl&) = default;
-  AsLiteralImpl& operator=(const AsLiteralImpl&) = default;
-
- private:
-  absl::string_view str_;
-
-  friend std::ostream& operator<<(std::ostream& os,
-                                  AsLiteralImpl&& as_literal) {
-    return os << as_literal.str_;
-  }
-  void AddToMessage(log_internal::LogMessage& m) {
-    m.CopyToEncodedBuffer<log_internal::LogMessage::StringType::kLiteral>(str_);
-  }
-  friend log_internal::LogMessage& operator<<(log_internal::LogMessage& m,
-                                              AsLiteralImpl as_literal) {
-    as_literal.AddToMessage(m);
-    return m;
-  }
-};
-
-enum class StructuredStringType {
-  kLiteral,
-  kNotLiteral,
-};
-
-// Structured log data for a string and associated structured proto field,
-// both of which must outlive this object.
-template <StructuredStringType str_type>
-class [[nodiscard]] AsStructuredStringTypeImpl final {
- public:
-  constexpr AsStructuredStringTypeImpl(
-      absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND,
-      StructuredProtoField field ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : str_(str), field_(field) {}
-
- private:
-  absl::string_view str_;
-  StructuredProtoField field_;
-
-  friend std::ostream& operator<<(std::ostream& os,
-                                  const AsStructuredStringTypeImpl& impl) {
-    return os << impl.str_;
-  }
-  void AddToMessage(LogMessage& m) const {
-    if (str_type == StructuredStringType::kLiteral) {
-      return m.CopyToEncodedBufferWithStructuredProtoField<
-          log_internal::LogMessage::StringType::kLiteral>(field_, str_);
-    } else {
-      return m.CopyToEncodedBufferWithStructuredProtoField<
-          log_internal::LogMessage::StringType::kNotLiteral>(field_, str_);
-    }
-  }
-  friend LogMessage& operator<<(LogMessage& m,
-                                const AsStructuredStringTypeImpl& impl) {
-    impl.AddToMessage(m);
-    return m;
-  }
-};
-
-using AsStructuredLiteralImpl =
-    AsStructuredStringTypeImpl<StructuredStringType::kLiteral>;
-using AsStructuredNotLiteralImpl =
-    AsStructuredStringTypeImpl<StructuredStringType::kNotLiteral>;
-
-// Structured log data for a stringifyable type T and associated structured
-// proto field, both of which must outlive this object.
-template <typename T>
-class [[nodiscard]] AsStructuredValueImpl final {
- public:
-  using ValueFormatter = absl::AnyInvocable<std::string(T) const>;
-
-  constexpr AsStructuredValueImpl(
-      T value ABSL_ATTRIBUTE_LIFETIME_BOUND,
-      StructuredProtoField field ABSL_ATTRIBUTE_LIFETIME_BOUND,
-      ValueFormatter value_formatter =
-          [](T value) { return absl::StrCat(value); })
-      : value_(value),
-        field_(field),
-        value_formatter_(std::move(value_formatter)) {}
-
- private:
-  T value_;
-  StructuredProtoField field_;
-  ValueFormatter value_formatter_;
-
-  friend std::ostream& operator<<(std::ostream& os,
-                                  const AsStructuredValueImpl& impl) {
-    return os << impl.value_formatter_(impl.value_);
-  }
-  void AddToMessage(LogMessage& m) const {
-    m.CopyToEncodedBufferWithStructuredProtoField<
-        log_internal::LogMessage::StringType::kNotLiteral>(
-        field_, value_formatter_(value_));
-  }
-  friend LogMessage& operator<<(LogMessage& m,
-                                const AsStructuredValueImpl& impl) {
-    impl.AddToMessage(m);
-    return m;
-  }
-};
-
-// Template deduction guide so `AsStructuredValueImpl(42, data)` works
-// without specifying the template type.
-template <typename T>
-AsStructuredValueImpl(T value, StructuredProtoField field)
-    -> AsStructuredValueImpl<T>;
-
-// Template deduction guide so `AsStructuredValueImpl(42, data, formatter)`
-// works without specifying the template type.
-template <typename T>
-AsStructuredValueImpl(
-    T value, StructuredProtoField field,
-    typename AsStructuredValueImpl<T>::ValueFormatter value_formatter)
-    -> AsStructuredValueImpl<T>;
-
-}  // namespace log_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_LOG_INTERNAL_STRUCTURED_H_

package/deps/abseil-cpp/absl/log/internal/structured_proto.cc

@@ -1,115 +0,0 @@
-//
-// Copyright 2024 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 "absl/log/internal/structured_proto.h"
-
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/log/internal/proto.h"
-#include "absl/types/span.h"
-#include "absl/types/variant.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace log_internal {
-
-namespace {
-
-// Handles protobuf-encoding a type contained inside
-// `StructuredProtoField::Varint`.
-struct VarintEncoderVisitor final {
-  template <typename T>
-  bool operator()(T value) const {
-    return EncodeVarint(field_number, value, &buf);
-  }
-
-  uint64_t field_number;
-  absl::Span<char>& buf;
-};
-
-// Handles protobuf-encoding a type contained inside
-// `StructuredProtoField::I64`.
-struct I64EncoderVisitor final {
-  bool operator()(uint64_t value) const {
-    return Encode64Bit(field_number, value, &buf);
-  }
-
-  bool operator()(int64_t value) const {
-    return Encode64Bit(field_number, value, &buf);
-  }
-
-  bool operator()(double value) const {
-    return EncodeDouble(field_number, value, &buf);
-  }
-
-  uint64_t field_number;
-  absl::Span<char>& buf;
-};
-
-// Handles protobuf-encoding a type contained inside
-// `StructuredProtoField::I32`.
-struct I32EncoderVisitor final {
-  bool operator()(uint32_t value) const {
-    return Encode32Bit(field_number, value, &buf);
-  }
-
-  bool operator()(int32_t value) const {
-    return Encode32Bit(field_number, value, &buf);
-  }
-
-  bool operator()(float value) const {
-    return EncodeFloat(field_number, value, &buf);
-  }
-
-  uint64_t field_number;
-  absl::Span<char>& buf;
-};
-
-// Handles protobuf-encoding a type contained inside `StructuredProtoField`.
-struct EncoderVisitor final {
-  bool operator()(StructuredProtoField::Varint varint) {
-    return absl::visit(VarintEncoderVisitor{field_number, buf}, varint);
-  }
-
-  bool operator()(StructuredProtoField::I64 i64) {
-    return absl::visit(I64EncoderVisitor{field_number, buf}, i64);
-  }
-
-  bool operator()(StructuredProtoField::LengthDelimited length_delimited) {
-    // No need for a visitor, since `StructuredProtoField::LengthDelimited` is
-    // just `absl::Span<const char>`.
-    return EncodeBytes(field_number, length_delimited, &buf);
-  }
-
-  bool operator()(StructuredProtoField::I32 i32) {
-    return absl::visit(I32EncoderVisitor{field_number, buf}, i32);
-  }
-
-  uint64_t field_number;
-  absl::Span<char>& buf;
-};
-
-}  // namespace
-
-bool EncodeStructuredProtoField(StructuredProtoField field,
-                                absl::Span<char>& buf) {
-  return absl::visit(EncoderVisitor{field.field_number, buf}, field.value);
-}
-
-}  // namespace log_internal
-
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/log/internal/structured_proto.h

@@ -1,107 +0,0 @@
-// Copyright 2024 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.
-//
-// -----------------------------------------------------------------------------
-// File: log/internal/structured_proto.h
-// -----------------------------------------------------------------------------
-
-#ifndef ABSL_LOG_INTERNAL_STRUCTURED_PROTO_H_
-#define ABSL_LOG_INTERNAL_STRUCTURED_PROTO_H_
-
-#include <cstddef>
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/log/internal/proto.h"
-#include "absl/types/span.h"
-#include "absl/types/variant.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace log_internal {
-
-// Sum type holding a single valid protobuf field suitable for encoding.
-struct StructuredProtoField final {
-  // Numeric type encoded with varint encoding:
-  // https://protobuf.dev/programming-guides/encoding/#varints
-  using Varint = absl::variant<uint64_t, int64_t, uint32_t, int32_t, bool>;
-
-  // Fixed-length 64-bit integer encoding:
-  // https://protobuf.dev/programming-guides/encoding/#non-varints
-  using I64 = absl::variant<uint64_t, int64_t, double>;
-
-  // Length-delimited record type (string, sub-message):
-  // https://protobuf.dev/programming-guides/encoding/#length-types
-  using LengthDelimited = absl::Span<const char>;
-
-  // Fixed-length 32-bit integer encoding:
-  // https://protobuf.dev/programming-guides/encoding/#non-varints
-  using I32 = absl::variant<uint32_t, int32_t, float>;
-
-  // Valid record type:
-  // https://protobuf.dev/programming-guides/encoding/#structure
-  using Value = absl::variant<Varint, I64, LengthDelimited, I32>;
-
-  // Field number for the protobuf value.
-  uint64_t field_number;
-
-  // Value to encode.
-  Value value;
-};
-
-// Estimates the number of bytes needed to encode `field` using
-// protobuf encoding.
-//
-// The returned value might be larger than the actual number of bytes needed.
-inline size_t BufferSizeForStructuredProtoField(StructuredProtoField field) {
-  // Visitor to estimate the number of bytes of one of the types contained
-  // inside `StructuredProtoField`.
-  struct BufferSizeVisitor final {
-    size_t operator()(StructuredProtoField::Varint /*unused*/) {
-      return BufferSizeFor(field_number, WireType::kVarint);
-    }
-
-    size_t operator()(StructuredProtoField::I64 /*unused*/) {
-      return BufferSizeFor(field_number, WireType::k64Bit);
-    }
-
-    size_t operator()(StructuredProtoField::LengthDelimited length_delimited) {
-      return BufferSizeFor(field_number, WireType::kLengthDelimited) +
-             length_delimited.size();
-    }
-
-    size_t operator()(StructuredProtoField::I32 /*unused*/) {
-      return BufferSizeFor(field_number, WireType::k32Bit);
-    }
-
-    uint64_t field_number;
-  };
-
-  return absl::visit(BufferSizeVisitor{field.field_number}, field.value);
-}
-
-// Encodes `field` into `buf` using protobuf encoding.
-//
-// On success, returns `true` and advances `buf` to the end of
-// the bytes consumed.
-//
-// On failure (if `buf` was too small), returns `false`.
-bool EncodeStructuredProtoField(StructuredProtoField field,
-                                absl::Span<char>& buf);
-
-}  // namespace log_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_LOG_INTERNAL_STRUCTURED_PROTO_H_

package/deps/abseil-cpp/absl/log/internal/structured_proto_test.cc

@@ -1,120 +0,0 @@
-//
-// Copyright 2024 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 "absl/log/internal/structured_proto.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
-#include "absl/utility/utility.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace log_internal {
-namespace {
-
-using ::testing::TestWithParam;
-
-struct StructuredProtoTestCase {
-  std::string test_name;
-  StructuredProtoField field;
-  std::vector<char> expected_encoded_field;
-};
-
-using StructuredProtoTest = TestWithParam<StructuredProtoTestCase>;
-
-TEST_P(StructuredProtoTest, Encoding) {
-  const StructuredProtoTestCase& test_case = GetParam();
-
-  // Greater than or equal to since BufferSizeForStructuredProtoField() is just
-  // an estimate of the data size and not an exact measurement.
-  ASSERT_GE(BufferSizeForStructuredProtoField(test_case.field),
-            test_case.expected_encoded_field.size());
-
-  std::vector<char> buf;
-  buf.resize(1024);
-
-  absl::Span<char> buf_span(buf);
-  EXPECT_TRUE(EncodeStructuredProtoField(test_case.field, buf_span));
-  size_t encoded_field_size = buf.size() - buf_span.size();
-
-  ASSERT_EQ(encoded_field_size, test_case.expected_encoded_field.size());
-  buf.resize(encoded_field_size);
-  EXPECT_EQ(buf, test_case.expected_encoded_field);
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    StructuredProtoTestSuiteInstantiation,
-    StructuredProtoTest,  // This is the name of your parameterized test
-    testing::ValuesIn<StructuredProtoTestCase>({
-        {
-            "Varint",
-            {
-                42,
-                StructuredProtoField::Value{
-                    absl::in_place_type<StructuredProtoField::Varint>,
-                    int32_t{23},
-                },
-            },
-            {'\xD0', '\x02', '\x17'},
-        },
-        {
-            "I64",
-            {
-                42,
-                StructuredProtoField::Value{
-                    absl::in_place_type<StructuredProtoField::I64>,
-                    int64_t{23},
-                },
-            },
-            {'\xD1', '\x02', '\x17', '\x00', '\x00', '\x00', '\x00', '\x00',
-             '\x00', '\x00'},
-        },
-        {
-            "LengthDelimited",
-            {
-                42,
-                // Use a string_view so the terminating NUL is excluded.
-                absl::string_view("Hello"),
-            },
-            {'\xD2', '\x02', '\x05', 'H', 'e', 'l', 'l', 'o'},
-        },
-        {
-            "I32",
-            {
-                42,
-                StructuredProtoField::Value{
-                    absl::in_place_type<StructuredProtoField::I32>,
-                    int32_t{23},
-                },
-            },
-            {'\xD5', '\x02', '\x17', '\x00', '\x00', '\x00'},
-        },
-    }),
-    [](const testing::TestParamInfo<StructuredProtoTest::ParamType>& info) {
-      return info.param.test_name;
-    });
-
-}  // namespace
-}  // namespace log_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/log/internal/test_actions.cc

@@ -1,75 +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 "absl/log/internal/test_actions.h"
-
-#include <cassert>
-#include <iostream>
-#include <string>
-#include <type_traits>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-#include "absl/time/time.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace log_internal {
-
-void WriteToStderrWithFilename::operator()(const absl::LogEntry& entry) const {
-  std::cerr << message << " (file: " << entry.source_filename() << ")\n";
-}
-
-void WriteEntryToStderr::operator()(const absl::LogEntry& entry) const {
-  if (!message.empty()) std::cerr << message << "\n";
-
-  const std::string source_filename = absl::CHexEscape(entry.source_filename());
-  const std::string source_basename = absl::CHexEscape(entry.source_basename());
-  const std::string text_message = absl::CHexEscape(entry.text_message());
-  const std::string encoded_message = absl::CHexEscape(entry.encoded_message());
-  std::string encoded_message_str;
-  std::cerr << "LogEntry{\n"                                               //
-            << "  source_filename: \"" << source_filename << "\"\n"        //
-            << "  source_basename: \"" << source_basename << "\"\n"        //
-            << "  source_line: " << entry.source_line() << "\n"            //
-            << "  prefix: " << (entry.prefix() ? "true\n" : "false\n")     //
-            << "  log_severity: " << entry.log_severity() << "\n"          //
-            << "  timestamp: " << entry.timestamp() << "\n"                //
-            << "  text_message: \"" << text_message << "\"\n"              //
-            << "  verbosity: " << entry.verbosity() << "\n"                //
-            << "  encoded_message (raw): \"" << encoded_message << "\"\n"  //
-            << encoded_message_str                                         //
-            << "}\n";
-}
-
-void WriteEntryToStderr::operator()(absl::LogSeverity severity,
-                                    absl::string_view filename,
-                                    absl::string_view log_message) const {
-  if (!message.empty()) std::cerr << message << "\n";
-  const std::string source_filename = absl::CHexEscape(filename);
-  const std::string text_message = absl::CHexEscape(log_message);
-  std::cerr << "LogEntry{\n"                                         //
-            << "  source_filename: \"" << source_filename << "\"\n"  //
-            << "  log_severity: " << severity << "\n"                //
-            << "  text_message: \"" << text_message << "\"\n"        //
-            << "}\n";
-}
-
-}  // namespace log_internal
-ABSL_NAMESPACE_END
-}  // namespace absl