diff --git a/CMake/AbseilDll.cmake b/CMake/AbseilDll.cmake
index b8b137c..cd633a1 100644
--- a/CMake/AbseilDll.cmake
+++ b/CMake/AbseilDll.cmake
@@ -331,6 +331,9 @@
   "strings/internal/cordz_update_tracker.h"
   "strings/internal/damerau_levenshtein_distance.h"
   "strings/internal/damerau_levenshtein_distance.cc"
+  "strings/internal/generic_printer.cc"
+  "strings/internal/generic_printer.h"
+  "strings/internal/generic_printer_internal.h"
   "strings/internal/stl_type_traits.h"
   "strings/internal/string_constant.h"
   "strings/internal/stringify_sink.h"
diff --git a/absl/log/internal/BUILD.bazel b/absl/log/internal/BUILD.bazel
index c5bdd67..32ae277 100644
--- a/absl/log/internal/BUILD.bazel
+++ b/absl/log/internal/BUILD.bazel
@@ -554,6 +554,9 @@
     hdrs = ["container.h"],
     copts = ABSL_DEFAULT_COPTS,
     linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = [
+        "//absl:__subpackages__",
+    ],
     deps = [
         "//absl/base:config",
         "//absl/meta:requires",
diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel
index 49051bd..a1e5021 100644
--- a/absl/strings/BUILD.bazel
+++ b/absl/strings/BUILD.bazel
@@ -1551,3 +1551,43 @@
         "@googletest//:gtest_main",
     ],
 )
+
+cc_library(
+    name = "generic_printer",
+    srcs = [
+        "internal/generic_printer.cc",
+        "internal/generic_printer_internal.h",
+    ],
+    hdrs = ["internal/generic_printer.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = [
+        "//absl:__subpackages__",
+    ],
+    deps = [
+        ":str_format",
+        ":strings",
+        "//absl/base:config",
+        "//absl/log/internal:container",
+        "//absl/meta:requires",
+    ],
+)
+
+cc_test(
+    name = "generic_printer_test",
+    srcs = ["internal/generic_printer_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":generic_printer",
+        ":strings",
+        "//absl/base:config",
+        "//absl/base:core_headers",
+        "//absl/container:flat_hash_map",
+        "//absl/log",
+        "//absl/status",
+        "//absl/status:statusor",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
diff --git a/absl/strings/CMakeLists.txt b/absl/strings/CMakeLists.txt
index 94e58ea..a03943d 100644
--- a/absl/strings/CMakeLists.txt
+++ b/absl/strings/CMakeLists.txt
@@ -1256,3 +1256,40 @@
     absl::strings
     GTest::gmock_main
 )
+
+absl_cc_library(
+  NAME
+    generic_printer_internal
+  SRCS
+    "internal/generic_printer.cc"
+    "internal/generic_printer_internal.h"
+  HDRS
+    "internal/generic_printer.h"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::config
+    absl::strings
+    absl::str_format
+    absl::log_internal_container
+    absl::requires_internal
+)
+
+absl_cc_test(
+  NAME
+    generic_printer_test
+  SRCS
+    "internal/generic_printer_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEPS
+    absl::base
+    absl::config
+    absl::flat_hash_map
+    absl::generic_printer_internal
+    absl::log
+    absl::status
+    absl::statusor
+    absl::strings
+    GTest::gmock_main
+)
diff --git a/absl/strings/internal/generic_printer.cc b/absl/strings/internal/generic_printer.cc
new file mode 100644
index 0000000..16ca228
--- /dev/null
+++ b/absl/strings/internal/generic_printer.cc
@@ -0,0 +1,107 @@
+// Copyright 2025 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/strings/internal/generic_printer.h"
+
+#include <cstddef>
+#include <cstdlib>
+#include <ostream>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/str_format.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace internal_generic_printer {
+
+// Out-of-line helper for PrintAsStringWithEscaping.
+std::ostream& PrintEscapedString(std::ostream& os, absl::string_view v) {
+  return os << "\"" << absl::CHexEscape(v) << "\"";
+}
+
+// Retuns a string representation of 'v', shortened if possible.
+template <class T, class F>
+std::string TryShorten(T v, F strtox) {
+  std::string printed =
+      absl::StrFormat("%.*g", std::numeric_limits<T>::max_digits10 / 2, v);
+  T parsed = strtox(printed.data());
+  if (parsed != v) {
+    printed =
+        absl::StrFormat("%.*g", std::numeric_limits<T>::max_digits10 + 1, v);
+  }
+  return printed;
+}
+
+// Out-of-line helpers for floating point values. These don't necessarily
+// ensure that values are precise, but rather that they are wide enough to
+// represent distinct values. go/c++17std/numeric.limits.members.html
+std::ostream& PrintPreciseFP(std::ostream& os, float v) {
+  return os << TryShorten(v, [](const char* buf) {
+           char* unused;
+           return std::strtof(buf, &unused);
+         }) << "f";
+}
+std::ostream& PrintPreciseFP(std::ostream& os, double v) {
+  return os << TryShorten(v, [](const char* buf) {
+           char* unused;
+           return std::strtod(buf, &unused);
+         });
+}
+std::ostream& PrintPreciseFP(std::ostream& os, long double v) {
+  return os << TryShorten(v, [](const char* buf) {
+           char* unused;
+           return std::strtold(buf, &unused);
+         }) << "L";
+}
+
+// Prints a nibble of 'v' in hexadecimal.
+inline char hexnib(int v) {
+  return static_cast<char>((v < 10 ? '0' : ('a' - 10)) + v);
+}
+
+template <typename T>
+static std::ostream& PrintCharImpl(std::ostream& os, T v) {
+  // Specialization for chars: print as 'c' if printable, otherwise
+  // hex-escaped.
+  return (absl::ascii_isprint(static_cast<unsigned char>(v))
+              ? (os << (v == '\'' ? "'\\" : "'") << v)
+              : (os << "'\\x" << hexnib((v >> 4) & 0xf) << hexnib(v & 0xf)))
+         << "' (0x" << hexnib((v >> 4) & 0xf) << hexnib(v & 0xf) << " "
+         << static_cast<int>(v) << ")";
+}
+
+std::ostream& PrintChar(std::ostream& os, char c) {
+  return PrintCharImpl(os, c);
+}
+
+std::ostream& PrintChar(std::ostream& os, signed char c) {
+  return PrintCharImpl(os, c);
+}
+
+std::ostream& PrintChar(std::ostream& os, unsigned char c) {
+  return PrintCharImpl(os, c);
+}
+
+std::ostream& PrintByte(std::ostream& os, std::byte b) {
+  auto v = std::to_integer<int>(b);
+  os << "0x" << hexnib((v >> 4) & 0xf) << hexnib(v & 0xf);
+  return os;
+}
+
+}  // namespace internal_generic_printer
+ABSL_NAMESPACE_END
+}  // namespace absl
diff --git a/absl/strings/internal/generic_printer.h b/absl/strings/internal/generic_printer.h
new file mode 100644
index 0000000..ed60155
--- /dev/null
+++ b/absl/strings/internal/generic_printer.h
@@ -0,0 +1,115 @@
+// Copyright 2025 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.
+
+#ifndef ABSL_STRINGS_INTERNAL_GENERIC_PRINTER_H_
+#define ABSL_STRINGS_INTERNAL_GENERIC_PRINTER_H_
+
+#include "absl/strings/internal/generic_printer_internal.h"  // IWYU pragma: export
+
+// Helpers for printing objects in generic code.
+//
+// These functions help with streaming in generic code. It may be desirable, for
+// example, to log values from generic functions; however, operator<< may not be
+// overloaded for all types.
+//
+// The helpers in this library use, in order of precedence:
+//
+//  1. std::string and std::string_view are quoted and escaped. (The specific
+//     format is not guaranteed to be stable.)
+//  2. A defined AbslStringify() method.
+//  3. absl::log_internal::LogContainer, if the object is a STL container.
+//  4. For std::tuple, std::pair, and std::optional, recursively calls
+//     GenericPrint for each element.
+//  5. Floating point values are printed with enough precision for round-trip.
+//  6. char values are quoted, with non-printable values escaped, and the
+//     char's numeric value is included.
+//  7. A defined operator<< overload (which should be found by ADL).
+//  8. A defined DebugString() const method.
+//  9. A fallback value with basic information otherwise.
+//
+// Note that the fallback value means that if no formatting conversion is
+// defined, you will not see a compile-time error. This also means that
+// GenericPrint() can safely be used in generic template contexts, and can
+// format any types needed (even though the output will vary).
+//
+// Example usage:
+//
+//   // All values after GenericPrint() are formatted:
+//   LOG(INFO) << GenericPrint()
+//             << int_var         // <- printed normally
+//             << float_var       // <- sufficient precision for round-trip
+//             << " unchanged literal text ";
+//
+//   // Just one value is formatted:
+//   LOG(INFO) << GenericPrint(string("this is quoted and escaped\t\n"))
+//             << GenericPrint("but not this, ");
+//             << string("and not this.");
+//
+// To make a type loggable with GenericPrint, prefer defining operator<< as a
+// friend function. For example:
+//
+//   class TypeToLog {
+//    public:
+//     string ToString() const;  // Many types already implement this.
+//                               // Define out-of-line if it is complex.
+//     friend std::ostream& operator<<(std::ostream& os, const TypeToLog& v) {
+//       return os << v.ToString();  // OK to define in-line instead, if simple.
+//     }
+//   };
+//
+// (Defining operator<< as an inline friend free function allows it to be found
+// by Argument-Dependent Lookup, or ADL, which is the mechanism typically used
+// for operator overload resolution. An inline friend function is the tightest
+// scope possible for overloading the left-hand side of an operator.)
+
+#include <ostream>
+#include <utility>
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// Helper for logging values in generic code.
+//
+// Example usage:
+//
+//   template <typename T>
+//   void GenericFunction() {
+//     T v1, v2;
+//     VLOG(1) << GenericPrint() << v1 << v2;  // GenericPrint everything
+//     VLOG(1) << GenericPrint(v1) << v2;  // GenericPrint just v1
+//   }
+//
+inline constexpr internal_generic_printer::GenericPrintAdapterFactory
+    GenericPrint{};
+
+// Generic printer type: this class can be used, for example, as a template
+// argument to allow users to provide alternative printing strategies.
+//
+// For example, to allow callers to provide a custom strategy:
+//
+//   template <typename T, typename PrinterT = GenericPrinter<T>>
+//   void GenericFunction() {
+//     T value;
+//     VLOG(1) << PrinterT{value};
+//   }
+//
+template <typename T>
+using GenericPrinter = internal_generic_printer::GenericPrinter<T>;
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_GENERIC_PRINTER_H_
diff --git a/absl/strings/internal/generic_printer_internal.h b/absl/strings/internal/generic_printer_internal.h
new file mode 100644
index 0000000..1a2d0bd
--- /dev/null
+++ b/absl/strings/internal/generic_printer_internal.h
@@ -0,0 +1,423 @@
+// Copyright 2025 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.
+
+#ifndef ABSL_STRINGS_INTERNAL_GENERIC_PRINTER_INTERNAL_H_
+#define ABSL_STRINGS_INTERNAL_GENERIC_PRINTER_INTERNAL_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/log/internal/container.h"
+#include "absl/meta/internal/requires.h"
+#include "absl/strings/has_absl_stringify.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+// NOTE: we do not want to expand the dependencies of this library. All
+// compatibility detection must be done in a generic way, without having to
+// include the headers of other libraries.
+
+// Internal implementation details: see generic_printer.h.
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace internal_generic_printer {
+
+template <typename T>
+std::ostream& GenericPrintImpl(std::ostream& os, const T& v);
+
+// Scope blocker: we must always use ADL in our predicates below.
+struct Anonymous;
+std::ostream& operator<<(const Anonymous&, const Anonymous&) = delete;
+
+// Logging policy for LogContainer. Our SFINAE overload will not fail
+// if the contained type cannot be printed, so make sure to circle back to
+// GenericPrinter.
+struct ContainerLogPolicy {
+  void LogOpening(std::ostream& os) const { os << "["; }
+  void LogClosing(std::ostream& os) const { os << "]"; }
+  void LogFirstSeparator(std::ostream& os) const { os << ""; }
+  void LogSeparator(std::ostream& os) const { os << ", "; }
+  int64_t MaxElements() const { return 15; }
+  template <typename T>
+  void Log(std::ostream& os, const T& element) const {
+    internal_generic_printer::GenericPrintImpl(os, element);
+  }
+  void LogEllipsis(std::ostream& os) const { os << "..."; }
+};
+
+// Out-of-line helper for PrintAsStringWithEscaping.
+std::ostream& PrintEscapedString(std::ostream& os, absl::string_view v);
+
+// Trait to recognize a string, possibly with a custom allocator.
+template <class T>
+inline constexpr bool is_any_string = false;
+template <class A>
+inline constexpr bool
+    is_any_string<std::basic_string<char, std::char_traits<char>, A>> = true;
+
+// Trait to recognize a supported pointer. Below are documented reasons why
+// raw pointers and std::shared_ptr are not currently supported.
+// See also http://b/239459272#comment9 and the discussion in the comment
+// threads of cl/485200996.
+//
+// The tl;dr:
+// 1. Pointers that logically represent an object (or nullptr) are safe to print
+//    out.
+// 2. Pointers that may represent some other concept (delineating memory bounds,
+//    overridden managed-memory deleters to mimic RAII, ...) may be unsafe to
+//    print out.
+//
+// raw pointers:
+//  - A pointer one-past the last element of an array
+//  - Non-null but non-dereferenceable: https://gcc.godbolt.org/z/sqsqGvKbP
+//
+// `std::shared_ptr`:
+//  - "Aliasing" / similar to raw pointers: https://gcc.godbolt.org/z/YbWPzvhae
+template <class T, class = void>
+inline constexpr bool is_supported_ptr = false;
+// `std::unique_ptr` has the same theoretical risks as raw pointers, but those
+// risks are far less likely (typically requiring a custom deleter), and the
+// benefits of supporting unique_ptr outweigh the costs.
+//  - Note: `std::unique_ptr<T[]>` cannot safely be and is not dereferenced.
+template <class A, class... Deleter>
+inline constexpr bool is_supported_ptr<std::unique_ptr<A, Deleter...>> = true;
+// `ArenaSafeUniquePtr` is at least as safe as `std::unique_ptr`.
+template <class T>
+inline constexpr bool is_supported_ptr<
+    T,
+    // Check for `ArenaSafeUniquePtr` without having to include its header here.
+    // This does match any type named `ArenaSafeUniquePtr`, regardless of the
+    // namespace it is defined in, but it's pretty plausible that any such type
+    // would be a fork.
+    decltype(T().~ArenaSafeUniquePtr())> = true;
+
+// Specialization for floats: print floating point types using their
+// max_digits10 precision. This ensures each distinct underlying values
+// can be represented uniquely, even though it's not (strictly speaking)
+// the most precise representation.
+std::ostream& PrintPreciseFP(std::ostream& os, float v);
+std::ostream& PrintPreciseFP(std::ostream& os, double v);
+std::ostream& PrintPreciseFP(std::ostream& os, long double v);
+
+std::ostream& PrintChar(std::ostream& os, char c);
+std::ostream& PrintChar(std::ostream& os, signed char c);
+std::ostream& PrintChar(std::ostream& os, unsigned char c);
+
+std::ostream& PrintByte(std::ostream& os, std::byte b);
+
+template <class... Ts>
+std::ostream& PrintTuple(std::ostream& os, const std::tuple<Ts...>& tuple) {
+  absl::string_view sep = "";
+  const auto print_one = [&](const auto& v) {
+    os << sep;
+    (GenericPrintImpl)(os, v);
+    sep = ", ";
+  };
+  os << "<";
+  std::apply([&](const auto&... v) { (print_one(v), ...); }, tuple);
+  os << ">";
+  return os;
+}
+
+template <typename T, typename U>
+std::ostream& PrintPair(std::ostream& os, const std::pair<T, U>& p) {
+  os << "<";
+  (GenericPrintImpl)(os, p.first);
+  os << ", ";
+  (GenericPrintImpl)(os, p.second);
+  os << ">";
+  return os;
+}
+
+template <typename T>
+std::ostream& PrintOptionalLike(std::ostream& os, const T& v) {
+  if (v.has_value()) {
+    os << "<";
+    (GenericPrintImpl)(os, *v);
+    os << ">";
+  } else {
+    (GenericPrintImpl)(os, std::nullopt);
+  }
+  return os;
+}
+
+template <typename... Ts>
+std::ostream& PrintVariant(std::ostream& os, const std::variant<Ts...>& v) {
+  os << "(";
+  os << "'(index = " << v.index() << ")' ";
+
+  // NOTE(derekbailey): This may throw a std::bad_variant_access if the variant
+  // is "valueless", which only occurs if exceptions are thrown. This is
+  // non-relevant when not using exceptions, but it is worth mentioning if that
+  // invariant is ever changed.
+  std::visit([&](const auto& arg) { (GenericPrintImpl)(os, arg); }, v);
+  os << ")";
+  return os;
+}
+
+template <typename StatusOrLike>
+std::ostream& PrintStatusOrLike(std::ostream& os, const StatusOrLike& v) {
+  os << "<";
+  if (v.ok()) {
+    os << "OK: ";
+    (GenericPrintImpl)(os, *v);
+  } else {
+    (GenericPrintImpl)(os, v.status());
+  }
+  os << ">";
+  return os;
+}
+
+template <typename SmartPointer>
+std::ostream& PrintSmartPointerContents(std::ostream& os,
+                                        const SmartPointer& v) {
+  os << "<";
+  if (v == nullptr) {
+    (GenericPrintImpl)(os, nullptr);
+  } else {
+    // Cast to void* so that every type (e.g. `char*`) is printed as an address.
+    os << absl::implicit_cast<const void*>(v.get()) << " pointing to ";
+
+    if constexpr (meta_internal::Requires<SmartPointer>(
+                      [](auto&& p) -> decltype(p[0]) {})) {
+      // e.g. std::unique_ptr<int[]>, which only has operator[]
+      os << "an array";
+    } else if constexpr (std::is_object_v<
+                             typename SmartPointer::element_type>) {
+      (GenericPrintImpl)(os, *v);
+    } else {
+      // e.g. std::unique_ptr<void, MyCustomDeleter>
+      os << "a non-object type";
+    }
+  }
+  os << ">";
+  return os;
+}
+
+template <typename T>
+std::ostream& GenericPrintImpl(std::ostream& os, const T& v) {
+  if constexpr (is_any_string<T> || std::is_same_v<T, absl::string_view>) {
+    // Specialization for strings: prints with plausible quoting and escaping.
+    return PrintEscapedString(os, v);
+  } else if constexpr (absl::HasAbslStringify<T>::value) {
+    // If someone has specified `AbslStringify`, we should prefer that.
+    return os << absl::StrCat(v);
+  } else if constexpr (meta_internal::Requires<const T>(
+                           [&](auto&& w)
+                               -> decltype((
+                                   PrintTuple)(std::declval<std::ostream&>(),
+                                               w)) {})) {
+    // For tuples, use `< elem0, ..., elemN >`.
+    return (PrintTuple)(os, v);
+
+  } else if constexpr (meta_internal::Requires<const T>(
+                           [&](auto&& w)
+                               -> decltype((
+                                   PrintPair)(std::declval<std::ostream&>(),
+                                              w)) {})) {
+    // For pairs, use `< first, second >`.
+    return (PrintPair)(os, v);
+
+  } else if constexpr (meta_internal::Requires<const T>(
+                           [&](auto&& w)
+                               -> decltype((
+                                   PrintVariant)(std::declval<std::ostream&>(),
+                                                 w)) {})) {
+    // For std::variant, use `std::visit(v)`
+    return (PrintVariant)(os, v);
+  } else if constexpr (is_supported_ptr<T>) {
+    return (PrintSmartPointerContents)(os, v);
+  } else if constexpr (meta_internal::Requires<const T>(
+                           [&](auto&& w) -> decltype(w.ok(), w.status(), *w) {
+                           })) {
+    return (PrintStatusOrLike)(os, v);
+  } else if constexpr (meta_internal::Requires<const T>(
+                           [&](auto&& w) -> decltype(w.has_value(), *w) {})) {
+    return (PrintOptionalLike)(os, v);
+  } else if constexpr (std::is_same_v<T, std::nullopt_t>) {
+    // Specialization for nullopt.
+    return os << "nullopt";
+
+  } else if constexpr (std::is_same_v<T, std::nullptr_t>) {
+    // Specialization for nullptr.
+    return os << "nullptr";
+
+  } else if constexpr (std::is_floating_point_v<T>) {
+    // For floating point print with enough precision for a roundtrip.
+    return PrintPreciseFP(os, v);
+
+  } else if constexpr (std::is_same_v<T, char> ||
+                       std::is_same_v<T, signed char> ||
+                       std::is_same_v<T, unsigned char>) {
+    // Chars are printed as the char (if a printable char) and the integral
+    // representation in hex and decimal.
+    return PrintChar(os, v);
+
+  } else if constexpr (std::is_same_v<T, std::byte>) {
+    return PrintByte(os, v);
+
+  } else if constexpr (std::is_same_v<T, bool> ||
+                       std::is_same_v<T,
+                                      typename std::vector<bool>::reference> ||
+                       std::is_same_v<
+                           T, typename std::vector<bool>::const_reference>) {
+    return os << (v ? "true" : "false");
+
+  } else if constexpr (meta_internal::Requires<const T>(
+                           [&](auto&& w)
+                               -> decltype(ProtobufInternalGetEnumDescriptor(
+                                   w)) {})) {
+    os << static_cast<std::underlying_type_t<T>>(v);
+    if (auto* desc =
+            ProtobufInternalGetEnumDescriptor(T{})->FindValueByNumber(v)) {
+      os << "(" << desc->name() << ")";
+    }
+    return os;
+  } else if constexpr (!std::is_enum_v<T> &&
+                       meta_internal::Requires<const T>(
+                           [&](auto&& w) -> decltype(absl::StrCat(w)) {})) {
+    return os << absl::StrCat(v);
+
+  } else if constexpr (meta_internal::Requires<const T>(
+                           [&](auto&& w)
+                               -> decltype(std::declval<std::ostream&>()
+                                           << log_internal::LogContainer(w)) {
+                           })) {
+    // For containers, use `[ elem0, ..., elemN ]` with a max of 15.
+    return os << log_internal::LogContainer(v, ContainerLogPolicy());
+
+  } else if constexpr (meta_internal::Requires<const T>(
+                           [&](auto&& w)
+                               -> decltype(std::declval<std::ostream&>() << w) {
+                           })) {
+    // Streaming
+    return os << v;
+
+  } else if constexpr (meta_internal::Requires<const T>(
+                           [&](auto&& w)
+                               -> decltype(std::declval<std::ostream&>()
+                                           << w.DebugString()) {})) {
+    // DebugString
+    return os << v.DebugString();
+
+  } else if constexpr (std::is_enum_v<T>) {
+    // In case the underlying type is some kind of char, we have to recurse.
+    return GenericPrintImpl(os, static_cast<std::underlying_type_t<T>>(v));
+
+  } else {
+    // Default: we don't have anything to stream the value.
+    return os << "[unprintable value of size " << sizeof(T) << " @" << &v
+              << "]";
+  }
+}
+
+// GenericPrinter always has a valid operator<<. It defers to the disjuction
+// above.
+template <typename T>
+class GenericPrinter {
+ public:
+  explicit GenericPrinter(const T& value) : value_(value) {}
+
+ private:
+  friend std::ostream& operator<<(std::ostream& os, const GenericPrinter& gp) {
+    return internal_generic_printer::GenericPrintImpl(os, gp.value_);
+  }
+  const T& value_;
+};
+
+struct GenericPrintStreamAdapter {
+  template <class StreamT>
+  struct Impl {
+    // Stream operator: this object will adapt to the underlying stream type,
+    // but only if the Impl is an rvalue. For example, this works:
+    //   std::cout << GenericPrint() << foo;
+    // but not:
+    //   auto adapter = (std::cout << GenericPrint());
+    //   adapter << foo;
+    template <typename T>
+    Impl&& operator<<(const T& value) && {
+      os << internal_generic_printer::GenericPrinter<T>(value);
+      return std::move(*this);
+    }
+
+    // Inhibit using a stack variable for the adapter:
+    template <typename T>
+    Impl& operator<<(const T& value) & = delete;
+
+    // Detects a Flush() method, for LogMessage compatibility.
+    template <typename T>
+    class HasFlushMethod {
+     private:
+      template <typename C>
+      static std::true_type Test(decltype(&C::Flush));
+      template <typename C>
+      static std::false_type Test(...);
+
+     public:
+      static constexpr bool value = decltype(Test<T>(nullptr))::value;
+    };
+
+    // LogMessage compatibility requires a Flush() method.
+    void Flush() {
+      if constexpr (HasFlushMethod<StreamT>::value) {
+        os.Flush();
+      }
+    }
+
+    StreamT& os;
+  };
+
+  // If Impl is evaluated on the RHS of an 'operator&&', and 'lhs && Impl.os'
+  // implicitly converts to void, then it's fine for Impl to do so, too. This
+  // will create precisely as many objects as 'lhs && Impl.os', so we should
+  // both observe any side effects, and avoid observing multiple side
+  // effects. (See absl::log_internal::Voidify for an example of why this might
+  // be useful.)
+  template <typename LHS, typename RHS>
+  friend auto operator&&(LHS&& lhs, Impl<RHS>&& rhs)
+      -> decltype(lhs && rhs.os) {
+    return lhs && rhs.os;
+  }
+
+  template <class StreamT>
+  friend Impl<StreamT> operator<<(StreamT& os, GenericPrintStreamAdapter&&) {
+    return Impl<StreamT>{os};
+  }
+};
+
+struct GenericPrintAdapterFactory {
+  internal_generic_printer::GenericPrintStreamAdapter operator()() const {
+    return internal_generic_printer::GenericPrintStreamAdapter{};
+  }
+  template <typename T>
+  internal_generic_printer::GenericPrinter<T> operator()(const T& value) const {
+    return internal_generic_printer::GenericPrinter<T>{value};
+  }
+};
+
+}  // namespace internal_generic_printer
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_GENERIC_PRINTER_INTERNAL_H_
diff --git a/absl/strings/internal/generic_printer_test.cc b/absl/strings/internal/generic_printer_test.cc
new file mode 100644
index 0000000..4093228
--- /dev/null
+++ b/absl/strings/internal/generic_printer_test.cc
@@ -0,0 +1,685 @@
+// Copyright 2025 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/strings/internal/generic_printer.h"
+
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <map>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/substitute.h"
+
+namespace generic_logging_test {
+struct NotStreamable {};
+}  // namespace generic_logging_test
+
+static std::ostream& operator<<(std::ostream& os,
+                                const generic_logging_test::NotStreamable&) {
+  return os << "This overload should NOT be found by GenericPrint.";
+}
+
+// Types to test selection logic for streamable and non-streamable types.
+namespace generic_logging_test {
+struct Streamable {
+  int x;
+  friend std::ostream& operator<<(std::ostream& os, const Streamable& l) {
+    return os << "Streamable{" << l.x << "}";
+  }
+};
+}  // namespace generic_logging_test
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+namespace {
+
+using ::testing::AllOf;
+using ::testing::AnyOf;
+using ::testing::ContainsRegex;
+using ::testing::EndsWith;
+using ::testing::Eq;
+using ::testing::HasSubstr;
+using ::testing::MatchesRegex;
+
+struct AbslStringifiable {
+  template <typename S>
+  friend void AbslStringify(S& sink, const AbslStringifiable&) {
+    sink.Append("AbslStringifiable!");
+  }
+};
+
+auto IsUnprintable() {
+#ifdef GTEST_USES_SIMPLE_RE
+  return HasSubstr("unprintable value of size");
+#else
+  return ContainsRegex(
+      "\\[unprintable value of size [0-9]+ @(0x)?[0-9a-fA-F]+\\]");
+#endif
+}
+
+auto HasExactlyNInstancesOf(int n, absl::string_view me) {
+#ifdef GTEST_USES_SIMPLE_RE
+  (void)n;
+  return HasSubstr(me);
+#else
+  absl::string_view value_m_times = "(.*$0){$1}.*";
+
+  return AllOf(MatchesRegex(absl::Substitute(value_m_times, me, n)),
+               Not(MatchesRegex(absl::Substitute(value_m_times, me, n + 1))));
+#endif
+}
+
+template <typename T>
+std::string GenericPrintToString(const T& v) {
+  std::stringstream ss;
+  ss << GenericPrint(v);
+  {
+    std::stringstream ss2;
+    ss2 << GenericPrint() << v;
+    EXPECT_EQ(ss.str(), ss2.str());
+  }
+  return ss.str();
+}
+
+TEST(GenericPrinterTest, Bool) {
+  EXPECT_EQ("true", GenericPrintToString(true));
+  EXPECT_EQ("false", GenericPrintToString(false));
+}
+
+TEST(GenericPrinterTest, VectorOfBool) {
+  std::vector<bool> v{true, false, true};
+  const auto& cv = v;
+  EXPECT_EQ("[true, false, true]", GenericPrintToString(v));
+  EXPECT_EQ("true", GenericPrintToString(v[0]));
+  EXPECT_EQ("true", GenericPrintToString(cv[0]));
+}
+
+TEST(GenericPrinterTest, CharLiterals) {
+  EXPECT_EQ(R"(a"\b)", GenericPrintToString(R"(a"\b)"));
+}
+
+TEST(GenericPrinterTest, Builtin) {
+  EXPECT_EQ("123", GenericPrintToString(123));
+}
+
+TEST(GenericPrinterTest, AbslStringifiable) {
+  EXPECT_EQ("AbslStringifiable!", GenericPrintToString(AbslStringifiable{}));
+}
+
+TEST(GenericPrinterTest, Nullptr) {
+  EXPECT_EQ("nullptr", GenericPrintToString(nullptr));
+}
+
+TEST(GenericPrinterTest, Chars) {
+  EXPECT_EQ(R"('\x0a' (0x0a 10))", GenericPrintToString('\x0a'));
+  EXPECT_EQ(R"(' ' (0x20 32))", GenericPrintToString(' '));
+  EXPECT_EQ(R"('~' (0x7e 126))", GenericPrintToString('~'));
+  EXPECT_EQ(R"('\'' (0x27 39))", GenericPrintToString('\''));
+}
+
+TEST(GenericPrinterTest, SignedChars) {
+  EXPECT_EQ(R"('\x0a' (0x0a 10))",
+            GenericPrintToString(static_cast<signed char>('\x0a')));
+  EXPECT_EQ(R"(' ' (0x20 32))",
+            GenericPrintToString(static_cast<signed char>(' ')));
+  EXPECT_EQ(R"('~' (0x7e 126))",
+            GenericPrintToString(static_cast<signed char>('~')));
+  EXPECT_EQ(R"('\'' (0x27 39))",
+            GenericPrintToString(static_cast<signed char>('\'')));
+}
+
+TEST(GenericPrinterTest, UnsignedChars) {
+  EXPECT_EQ(R"('\x0a' (0x0a 10))",
+            GenericPrintToString(static_cast<unsigned char>('\x0a')));
+  EXPECT_EQ(R"(' ' (0x20 32))",
+            GenericPrintToString(static_cast<unsigned char>(' ')));
+  EXPECT_EQ(R"('~' (0x7e 126))",
+            GenericPrintToString(static_cast<unsigned char>('~')));
+  EXPECT_EQ(R"('\'' (0x27 39))",
+            GenericPrintToString(static_cast<unsigned char>('\'')));
+}
+
+TEST(GenericPrinterTest, Bytes) {
+  EXPECT_EQ("0x00", GenericPrintToString(static_cast<std::byte>(0)));
+  EXPECT_EQ("0x7f", GenericPrintToString(static_cast<std::byte>(0x7F)));
+  EXPECT_EQ("0xff", GenericPrintToString(static_cast<std::byte>(0xFF)));
+}
+
+TEST(GenericPrinterTest, Strings) {
+  const std::string expected_quotes = R"("a\"\\b")";
+  EXPECT_EQ(expected_quotes, GenericPrintToString(std::string(R"(a"\b)")));
+  const std::string expected_nonprintable = R"("\x00\xcd\n\xab")";
+  EXPECT_EQ(expected_nonprintable,
+            GenericPrintToString(absl::string_view("\0\315\n\xAB", 4)));
+}
+
+TEST(GenericPrinterTest, PreciseFloat) {
+  // Instead of testing exactly how the values are formatted, just check that
+  // they are distinct.
+
+  // Ensure concise output for exact values:
+  EXPECT_EQ("1f", GenericPrintToString(1.f));
+  EXPECT_EQ("1.1f", GenericPrintToString(1.1f));
+
+  // Plausible real-world values:
+  float f = 10.0000095f;
+  EXPECT_NE(GenericPrintToString(f), GenericPrintToString(10.0000105f));
+  // Smallest increment for a real-world value:
+  EXPECT_NE(GenericPrintToString(f),
+            GenericPrintToString(std::nextafter(f, 11)));
+  // The two smallest (finite) values possible:
+  EXPECT_NE(GenericPrintToString(std::numeric_limits<float>::lowest()),
+            GenericPrintToString(
+                std::nextafter(std::numeric_limits<float>::lowest(), 1)));
+  // Ensure the value has the correct type suffix:
+  EXPECT_THAT(GenericPrintToString(0.f), EndsWith("f"));
+}
+
+TEST(GenericPrinterTest, PreciseDouble) {
+  EXPECT_EQ("1", GenericPrintToString(1.));
+  EXPECT_EQ("1.1", GenericPrintToString(1.1));
+  double d = 10.000000000000002;
+  EXPECT_NE(GenericPrintToString(d), GenericPrintToString(10.000000000000004));
+  EXPECT_NE(GenericPrintToString(d),
+            GenericPrintToString(std::nextafter(d, 11)));
+  EXPECT_NE(GenericPrintToString(std::numeric_limits<double>::lowest()),
+            GenericPrintToString(
+                std::nextafter(std::numeric_limits<double>::lowest(), 1)));
+  EXPECT_THAT(GenericPrintToString(0.), EndsWith("0"));
+}
+
+TEST(GenericPrinterTest, PreciseLongDouble) {
+  EXPECT_EQ("1L", GenericPrintToString(1.L));
+  EXPECT_EQ("1.1L", GenericPrintToString(1.1L));
+  long double ld = 10.0000000000000000000000000000002;
+  EXPECT_NE(GenericPrintToString(ld),
+            GenericPrintToString(10.0000000000000000000000000000004));
+  EXPECT_NE(GenericPrintToString(ld),
+            GenericPrintToString(std::nextafter(ld, 11)));
+  EXPECT_NE(GenericPrintToString(std::numeric_limits<long double>::lowest()),
+            GenericPrintToString(
+                std::nextafter(std::numeric_limits<long double>::lowest(), 1)));
+  EXPECT_THAT(GenericPrintToString(0.L), EndsWith("L"));
+}
+
+TEST(GenericPrinterTest, StreamableLvalue) {
+  generic_logging_test::Streamable x{234};
+  EXPECT_EQ("Streamable{234}", GenericPrintToString(x));
+}
+
+TEST(GenericPrinterTest, StreamableXvalue) {
+  EXPECT_EQ("Streamable{345}",
+            GenericPrintToString(generic_logging_test::Streamable{345}));
+}
+
+TEST(GenericPrinterTest, NotStreamableWithoutGenericPrint) {
+  ::generic_logging_test::NotStreamable x;
+  std::stringstream ss;
+  ::operator<<(ss, x);
+  EXPECT_EQ(ss.str(), "This overload should NOT be found by GenericPrint.");
+}
+
+TEST(GenericPrinterTest, NotStreamableLvalue) {
+  generic_logging_test::NotStreamable x;
+  EXPECT_THAT(GenericPrintToString(x), IsUnprintable());
+}
+
+TEST(GenericPrinterTest, NotStreamableXvalue) {
+  EXPECT_THAT(GenericPrintToString(generic_logging_test::NotStreamable{}),
+              IsUnprintable());
+}
+
+TEST(GenericPrinterTest, DebugString) {
+  struct WithDebugString {
+    std::string val;
+    std::string DebugString() const {
+      return absl::StrCat("WithDebugString{", val, "}");
+    }
+  };
+  EXPECT_EQ("WithDebugString{foo}",
+            GenericPrintToString(WithDebugString{"foo"}));
+}
+
+TEST(GenericPrinterTest, Vector) {
+  std::vector<int> v = {4, 5, 6};
+  EXPECT_THAT(GenericPrintToString(v), MatchesRegex(".*4,? 5,? 6.*"));
+}
+
+TEST(GenericPrinterTest, StreamableVector) {
+  std::vector<generic_logging_test::Streamable> v = {{7}, {8}, {9}};
+  EXPECT_THAT(GenericPrintToString(v),
+              MatchesRegex(".*Streamable.7.,? Streamable.8.,? Streamable.9.*"));
+}
+
+TEST(GenericPrinterTest, Map) {
+  absl::flat_hash_map<
+      std::string, absl::flat_hash_map<std::string, std::pair<double, double>>>
+      v = {{"A", {{"B", {.5, .25}}}}};
+
+  EXPECT_THAT(GenericPrintToString(v), R"([<"A", [<"B", <0.5, 0.25>>]>])");
+
+  std::map<std::string, std::map<std::string, std::pair<double, double>>> v2 = {
+      {"A", {{"B", {.5, .25}}}}};
+
+  EXPECT_THAT(GenericPrintToString(v2), R"([<"A", [<"B", <0.5, 0.25>>]>])");
+}
+
+TEST(GenericPrinterTest, StreamAdapter) {
+  std::stringstream ss;
+  static_assert(
+      std::is_same<
+          typename std::remove_reference<decltype(ss << GenericPrint())>::type,
+          internal_generic_printer::GenericPrintStreamAdapter::Impl<
+              std::stringstream>>::value,
+      "expected ostream << GenericPrint() to yield adapter impl");
+
+  ss << GenericPrint() << "again, " << "back-up, " << "cue, "
+     << "double-u, " << "eye, "
+     << "four: " << generic_logging_test::NotStreamable{};
+  EXPECT_THAT(
+      ss.str(),
+      MatchesRegex(
+          "again, back-up, cue, double-u, eye, four: .unprintable value.*"));
+}
+
+TEST(GenericPrinterTest, NotStreamableVector) {
+  std::vector<generic_logging_test::NotStreamable> v = {{}, {}, {}};
+#ifdef GTEST_USES_SIMPLE_RE
+  EXPECT_THAT(GenericPrintToString(v), HasSubstr("unprintable"));
+#else
+  EXPECT_THAT(GenericPrintToString(v), MatchesRegex(".*(unprintable.*){3}.*"));
+#endif
+}
+
+struct CustomContainer : public std::array<int, 4> {
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const CustomContainer& c) {
+    absl::Format(&sink, "%d %d", c[0], c[1]);
+  }
+};
+
+// Checks that AbslStringify (go/totw/215) is respected for container-like
+// types.
+TEST(GenericPrinterTest, ContainerLikeCustomLogging) {
+  CustomContainer c = {1, 2, 3, 4};
+  EXPECT_EQ(GenericPrintToString(c), "1 2");
+}
+
+// Test helper: this function demonstrates customizable printing logic:
+// 'GenericPrinter<T>' can be nominated as a default template argument.
+template <typename T, typename Printer = GenericPrinter<T>>
+std::string SpecializablePrint(const T& v) {
+  std::stringstream ss;
+  ss << Printer{v};
+  return ss.str();
+}
+
+TEST(GenericPrinterTest, DefaultPrinter) {
+  EXPECT_EQ("123", SpecializablePrint(123));
+}
+
+// Example of custom printing logic. This doesn't actually test anything in
+// GenericPrinter, but it's a working example of customizing printing logic (as
+// opposed to the comments in generic_printer.h).
+struct CustomPrinter {
+  explicit CustomPrinter(int) {}
+  friend std::ostream& operator<<(std::ostream& os, CustomPrinter&&) {
+    return os << "custom printer";
+  }
+};
+
+TEST(GenericPrinterTest, CustomPrinter) {
+  EXPECT_EQ("custom printer", (SpecializablePrint<int, CustomPrinter>(123)));
+}
+
+TEST(GenricPrinterTest, Nullopt) {
+  EXPECT_EQ("nullopt", GenericPrintToString(std::nullopt));
+}
+
+TEST(GenericPrinterTest, Optional) {
+  EXPECT_EQ("nullopt", GenericPrintToString(std::optional<int>()));
+  EXPECT_EQ("nullopt", GenericPrintToString(std::optional<int>(std::nullopt)));
+  EXPECT_EQ("<3>", GenericPrintToString(std::make_optional(3)));
+  EXPECT_EQ("<Streamable{3}>", GenericPrintToString(std::make_optional(
+                                   generic_logging_test::Streamable{3})));
+}
+
+TEST(GenericPrinterTest, Tuple) {
+  EXPECT_EQ("<1, two, 3>", GenericPrintToString(std::make_tuple(1, "two", 3)));
+}
+
+TEST(GenericPrinterTest, EmptyTuple) {
+  EXPECT_EQ("<>", GenericPrintToString(std::make_tuple()));
+}
+
+TEST(GenericPrinterTest, TupleWithStreamableMember) {
+  EXPECT_EQ("<1, two, Streamable{3}>",
+            GenericPrintToString(std::make_tuple(
+                1, "two", generic_logging_test::Streamable{3})));
+}
+
+TEST(GenericPrinterTest, Variant) {
+  EXPECT_EQ(R"(('(index = 0)' "cow"))",
+            GenericPrintToString(std::variant<std::string, float>("cow")));
+
+  EXPECT_EQ("('(index = 1)' 1.1f)",
+            GenericPrintToString(std::variant<std::string, float>(1.1F)));
+}
+
+TEST(GenericPrinterTest, VariantMonostate) {
+  EXPECT_THAT(GenericPrintToString(std::variant<std::monostate, std::string>()),
+              IsUnprintable());
+}
+
+TEST(GenericPrinterTest, VariantNonStreamable) {
+  EXPECT_EQ(R"(('(index = 0)' "cow"))",
+            GenericPrintToString(
+                std::variant<std::string, generic_logging_test::NotStreamable>(
+                    "cow")));
+
+  EXPECT_THAT(
+      GenericPrintToString(
+          std::variant<std::string, generic_logging_test::NotStreamable>(
+              generic_logging_test::NotStreamable{})),
+      IsUnprintable());
+}
+
+TEST(GenericPrinterTest, VariantNestedVariant) {
+  EXPECT_EQ(
+      "('(index = 1)' ('(index = 1)' 1.1f))",
+      GenericPrintToString(std::variant<std::string, std::variant<int, float>>(
+          std::variant<int, float>(1.1F))));
+}
+
+TEST(GenericPrinterTest, VariantInPlace) {
+  EXPECT_EQ("('(index = 0)' 17)", GenericPrintToString(std::variant<int, int>(
+                                      std::in_place_index<0>, 17)));
+
+  EXPECT_EQ("('(index = 1)' 17)", GenericPrintToString(std::variant<int, int>(
+                                      std::in_place_index<1>, 17)));
+}
+
+TEST(GenericPrinterTest, StatusOrLikeOkPrintsValue) {
+  EXPECT_EQ(R"(<OK: "cow">)",
+            GenericPrintToString(absl::StatusOr<std::string>("cow")));
+
+  EXPECT_EQ(R"(<OK: 1.1f>)", GenericPrintToString(absl::StatusOr<float>(1.1F)));
+}
+
+TEST(GenericPrinterTest, StatusOrLikeNonOkPrintsStatus) {
+  EXPECT_THAT(
+      GenericPrintToString(absl::StatusOr<float>(
+          absl::InvalidArgumentError("my error message"))),
+      AllOf(HasSubstr("my error message"), HasSubstr("INVALID_ARGUMENT")));
+
+  EXPECT_THAT(GenericPrintToString(
+                  absl::StatusOr<int>(absl::AbortedError("other message"))),
+              AllOf(HasSubstr("other message"), HasSubstr("ABORTED")));
+}
+
+TEST(GenericPrinterTest, StatusOrLikeNonStreamableValueUnprintable) {
+  EXPECT_THAT(
+      GenericPrintToString(absl::StatusOr<generic_logging_test::NotStreamable>(
+          generic_logging_test::NotStreamable{})),
+      IsUnprintable());
+}
+
+TEST(GenericPrinterTest, StatusOrLikeNonStreamableErrorStillPrintable) {
+  EXPECT_THAT(
+      GenericPrintToString(absl::StatusOr<generic_logging_test::NotStreamable>(
+          absl::AbortedError("other message"))),
+      AllOf(HasSubstr("other message"), HasSubstr("ABORTED")));
+}
+
+TEST(GenericPrinterTest, IsSupportedPointer) {
+  using internal_generic_printer::is_supported_ptr;
+
+  EXPECT_TRUE(is_supported_ptr<std::unique_ptr<std::string>>);
+  EXPECT_TRUE(is_supported_ptr<std::unique_ptr<int[]>>);
+  EXPECT_TRUE((is_supported_ptr<std::unique_ptr<void, void (*)(void*)>>));
+
+  EXPECT_FALSE(is_supported_ptr<int*>);
+  EXPECT_FALSE(is_supported_ptr<std::shared_ptr<int>>);
+  EXPECT_FALSE(is_supported_ptr<std::weak_ptr<int>>);
+}
+
+TEST(GenericPrinterTest, SmartPointerPrintsNullptrForAllNullptrs) {
+  std::unique_ptr<std::string> up;
+
+  EXPECT_EQ("<nullptr>", GenericPrintToString(up));
+}
+
+TEST(GenericPrinterTest, SmartPointerPrintsValueIfNonNull) {
+  EXPECT_THAT(GenericPrintToString(std::make_unique<int>(5)),
+              HasSubstr("pointing to 5"));
+}
+
+TEST(GenericPrinterTest, SmartPointerPrintsAddressOfPointee) {
+  auto i = std::make_unique<int>(5);
+  auto c = std::make_unique<char>('z');
+  char memory[] = "abcdefg";
+  auto cp = std::make_unique<char*>(memory);
+
+  EXPECT_THAT(GenericPrintToString(i),
+              AnyOf(Eq(absl::StrFormat("<%016X pointing to 5>",
+                                       reinterpret_cast<intptr_t>(&*i))),
+                    Eq(absl::StrFormat("<%#x pointing to 5>",
+                                       reinterpret_cast<intptr_t>(&*i)))));
+
+  EXPECT_THAT(
+      GenericPrintToString(c),
+      AnyOf(HasSubstr(absl::StrFormat("<%016X pointing to 'z'",
+                                      reinterpret_cast<intptr_t>(&*c))),
+            HasSubstr(absl::StrFormat("<%#x pointing to 'z'",
+                                      reinterpret_cast<intptr_t>(&*c)))));
+
+  EXPECT_THAT(GenericPrintToString(cp),
+              AnyOf(Eq(absl::StrFormat("<%016X pointing to abcdefg>",
+                                       reinterpret_cast<intptr_t>(&*cp))),
+                    Eq(absl::StrFormat("<%#x pointing to abcdefg>",
+                                       reinterpret_cast<intptr_t>(&*cp)))));
+}
+
+TEST(GenericPrinterTest, SmartPointerToArrayOnlyPrintsAddressAndHelpText) {
+  auto empty = std::make_unique<int[]>(0);
+  auto nonempty = std::make_unique<int[]>(5);
+  nonempty[0] = 12345;
+  nonempty[4] = 54321;
+  // NOTE: ArenaSafeUniquePtr is not meant to support array-type template
+  // parameters, so we skip testing that here.
+  // http://g/c-users/J-AEFrFHssY/UMMFzCkdBAAJ, b/265984185.
+
+  EXPECT_THAT(
+      GenericPrintToString(nonempty),
+      AllOf(AnyOf(HasSubstr(absl::StrFormat(
+                      "%016X", reinterpret_cast<intptr_t>(nonempty.get()))),
+                  HasSubstr(absl::StrFormat(
+                      "%#x", reinterpret_cast<intptr_t>(nonempty.get())))),
+            HasSubstr("array"), Not(HasSubstr("to 54321")),
+            Not(HasSubstr("to 12345"))));
+
+  EXPECT_THAT(
+      GenericPrintToString(empty),
+      AllOf(AnyOf(HasSubstr(absl::StrFormat(
+                      "%016X", reinterpret_cast<intptr_t>(empty.get()))),
+                  HasSubstr(absl::StrFormat(
+                      "%#x", reinterpret_cast<intptr_t>(empty.get())))),
+            HasSubstr("array")));
+}
+
+TEST(GenericPrinterTest, SmartPointerToNonObjectType) {
+  auto int_ptr_deleter = [](void* data) {
+    int* p = static_cast<int*>(data);
+    delete p;
+  };
+
+  std::unique_ptr<void, decltype(int_ptr_deleter)> void_ptr(new int(959),
+                                                            int_ptr_deleter);
+
+  EXPECT_THAT(GenericPrintToString(void_ptr),
+              HasSubstr("pointing to a non-object type"));
+}
+
+TEST(GenericPrinterTest, PrintsCustomDeleterSmartPointer) {
+  // Delete `p` (if not nullptr) only on the 4th time the deleter is used.
+  auto four_deleter = [](std::string* p) {
+    static int counter = 0;
+    if (p == nullptr) return;  // skip calls to moved-from destructors.
+    if (++counter >= 4) delete p;
+  };
+
+  // Have four `unique_ptr`s "manage" the same string-pointer, with only the
+  // final (4th) call to the deleter deleting the string pointer.
+  auto* unique_string = new std::string("unique string");
+  std::vector<std::unique_ptr<std::string, decltype(four_deleter)>> test_ptrs;
+  for (int i = 0; i < 4; ++i) {
+    test_ptrs.emplace_back(unique_string, four_deleter);
+  }
+
+  EXPECT_THAT(GenericPrintToString(test_ptrs),
+              HasExactlyNInstancesOf(4, "unique string"));
+}
+
+// Ensure that GenericPrint is robust to recursion when a type's operator<<
+// calls into GenericPrint internally.
+struct CustomRecursive {
+  std::unique_ptr<CustomRecursive> next;
+  int val = 0;
+
+  friend std::ostream& operator<<(std::ostream& os, const CustomRecursive& cr) {
+    return os << "custom print: next = " << GenericPrintToString(cr.next);
+  }
+};
+
+TEST(GenericPrinterTest, DISABLED_CustomPrintOverloadRecursionDetected) {
+  auto r1 = std::make_unique<CustomRecursive>();
+  r1->val = 1;
+  auto& r2 = r1->next = std::make_unique<CustomRecursive>();
+  r2->val = 2;
+  r2->next = std::move(r1);
+
+  EXPECT_THAT(GenericPrintToString(*r2),
+              AllOf(HasExactlyNInstancesOf(2, "custom print"),
+                    HasExactlyNInstancesOf(1, "<recursive>")));
+
+  r2->next = nullptr;  // break the cycle
+}
+// <end DISABLED_ test section>
+
+enum CStyleEnum { kValue0, kValue1 };
+TEST(GenericPrinterTest, Enum) {
+  EXPECT_EQ("1", GenericPrintToString(kValue1));
+}
+
+enum class CppStyleEnum { kValue0, kValue1, kValue2 };
+TEST(GenericPrinterTest, EnumClass) {
+  EXPECT_EQ("2", GenericPrintToString(CppStyleEnum::kValue2));
+}
+
+enum class CharBasedEnum : char { kValueA = 'A', kValue1 = '\x01' };
+TEST(GenericPrinterTest, CharBasedEnum) {
+  EXPECT_EQ("'A' (0x41 65)", GenericPrintToString(CharBasedEnum::kValueA));
+  EXPECT_EQ("'\\x01' (0x01 1)", GenericPrintToString(CharBasedEnum::kValue1));
+}
+
+enum class WideBasedEnum : uint64_t {
+  kValue = std::numeric_limits<uint64_t>::max()
+};
+TEST(GenericPrinterTest, WideBasedEnum) {
+  EXPECT_EQ(absl::StrCat(std::numeric_limits<uint64_t>::max()),
+            GenericPrintToString(WideBasedEnum::kValue));
+}
+
+enum CStyleEnumWithStringify { kValueA = 0, kValueB = 2 };
+template <typename Sink>
+void AbslStringify(Sink& sink, CStyleEnumWithStringify e) {
+  switch (e) {
+    case CStyleEnumWithStringify::kValueA:
+      sink.Append("A");
+      return;
+    case CStyleEnumWithStringify::kValueB:
+      sink.Append("B");
+      return;
+  }
+  sink.Append("??");
+}
+TEST(GenericPrinterTest, CStyleEnumWithStringify) {
+  EXPECT_EQ("A", GenericPrintToString(CStyleEnumWithStringify::kValueA));
+  EXPECT_EQ("??",
+            GenericPrintToString(static_cast<CStyleEnumWithStringify>(1)));
+}
+
+enum class CppStyleEnumWithStringify { kValueA, kValueB, kValueC };
+template <typename Sink>
+void AbslStringify(Sink& sink, CppStyleEnumWithStringify e) {
+  switch (e) {
+    case CppStyleEnumWithStringify::kValueA:
+      sink.Append("A");
+      return;
+    case CppStyleEnumWithStringify::kValueB:
+      sink.Append("B");
+      return;
+    case CppStyleEnumWithStringify::kValueC:
+      sink.Append("C");
+      return;
+  }
+  sink.Append("??");
+}
+TEST(GenericPrinterTest, CppStyleEnumWithStringify) {
+  EXPECT_EQ("A", GenericPrintToString(CppStyleEnumWithStringify::kValueA));
+  EXPECT_EQ("??",
+            GenericPrintToString(static_cast<CppStyleEnumWithStringify>(17)));
+}
+
+enum class CharBasedEnumWithStringify : char { kValueA = 'A', kValueB = 'B' };
+template <typename Sink>
+void AbslStringify(Sink& sink, CharBasedEnumWithStringify e) {
+  switch (e) {
+    case CharBasedEnumWithStringify::kValueA:
+      sink.Append("charA");
+      return;
+    case CharBasedEnumWithStringify::kValueB:
+      sink.Append("charB");
+      return;
+  }
+  sink.Append("??");
+}
+TEST(GenericPrinterTest, CharBasedEnumWithStringify) {
+  EXPECT_EQ("charA", GenericPrintToString(CharBasedEnumWithStringify::kValueA));
+  EXPECT_EQ("??",
+            GenericPrintToString(static_cast<CharBasedEnumWithStringify>('W')));
+}
+
+}  // namespace
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl