[libc] Add Printf FormatSection Matcher

[michaelrj]

Summary

This patch changes the printf parser tests to use a more robust matcher.
This allows for better debugging of parsing issues. This does not affect
the actual printf code at all, only the tests.

[lntue]

libc/utils/UnitTest/PrintfMatcher.cpp

72

You might want to wrap the template int_to_hex and display function inside an anonymous namespace.

libc/utils/UnitTest/PrintfMatcher.h

39

Since *form* is also an actual word, it might be better to change these macros to EXPECT/ASSERT_FORMAT_EQ

[michaelrj]

address comments

[sivachandra]

libc/utils/UnitTest/PrintfMatcher.cpp

18

Instead of all the comparisons in this function, can you define operator== on FormatSection?

25

We can use cpp::StringView to perform this comparison.

53

We have this: https://github.com/llvm/llvm-project/blob/main/libc/utils/UnitTest/FPMatcher.cpp#L23

You can move it to a common place may be? You can use std::string in this file.

67

Wrap this in a do-while?

118

"Expected format section: "

121

"Actual format section: "

[michaelrj]

add a util file for int_to_hex and address other comments

libc/utils/UnitTest/PrintfMatcher.cpp

18

I think it's better for final code size if FormatSection doesn't have the comparison operator since it's never used in actual printf code.

25

we could create StringViews for these, but I don't see a reason to, since this is closer to the way these objects are actually used.

53

I've done that, does the bazel also need an update?

[sivachandra]

libc/utils/UnitTest/PrintfMatcher.cpp

18

Unused inline functions/methods will not contribute to code size. Also, applications which care about code size will/should use LTO which will kick out all unused functions. You can add a comment along side operator== to make it clear that it is used only for testing.

25

It could be used differently elsewhere but you are comparing two string views here. So, the following is much better and avoids duplication of code:

if (cpp::StringView(expected.raw_string, expected.raw_len) != cpp::StringView(expected.raw_string, expected.raw_len))
  return false;

It also makes the conditional on line 23 simpler:

if (expected.has_conv != actual.has_conv)
  return false;

[michaelrj]

address comments

libc/utils/UnitTest/PrintfMatcher.cpp

18

alright, in that case I'll just do it.

25

Ah, I thought StringView was more complicated than that. I've done that.

[lntue]

libc/src/stdio/printf_core/core_structs.h

55

FormatSection is quite big, you should use const-ref:

bool operator==(const FormatSection &other) const { ... }

[sivachandra]

OK after addressing @lntue's comment.

[sivachandra]

libc/utils/UnitTest/CMakeLists.txt

20

Ah, if you add this with add_header_library, you will not require the empty cpp file.

[michaelrj]

address comments

[michaelrj]

final clean up before land

libc/src/stdio/printf_core/core_structs.h

 //===-- Core Structures for printf ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CORE_STRUCTS_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CORE_STRUCTS_H
 
+#include "src/__support/CPP/StringView.h"
+
 #include <inttypes.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 // These length modifiers match the length modifiers in the format string, which
 // is why they are formatted differently from the rest of the file.
struct FormatSection {
   LengthModifier length_modifier = LengthModifier::none;
   int min_width = 0;
   int precision = -1;
 
   __uint128_t conv_val_raw; // Needs to be large enough to hold a long double.
   void *conv_val_ptr;
 
   char conv_name;
+
+  // This operator is only used for testing and should be automatically
+  // optimized out for release builds.
+  bool operator==(FormatSection other) {
+    if (has_conv != other.has_conv)
+      return false;
+
+    if (!cpp::StringView(raw_string, raw_len)
+             .equals(cpp::StringView(other.raw_string, other.raw_len)))
+      return false;
+
+    if (has_conv) {
+      if (!((static_cast<uint8_t>(flags) ==
+             static_cast<uint8_t>(other.flags)) &&
+            (min_width == other.min_width) && (precision == other.precision) &&
+            (length_modifier == other.length_modifier) &&
+            (conv_name == other.conv_name)))
+        return false;
+
+      if (conv_name == 'p' || conv_name == 'n' || conv_name == 's')
+        return (conv_val_ptr == other.conv_val_ptr);
+      else if (conv_name != '%')
+        return (conv_val_raw == other.conv_val_raw);
+    }
+    return true;
+  }
 };
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CORE_STRUCTS_H

libc/test/src/stdio/printf_core/CMakeLists.txt

 add_libc_unittest(
   parser_test
   SUITE
     libc_stdio_unittests
   SRCS
     parser_test.cpp
   DEPENDS
     libc.src.stdio.printf_core.parser
     libc.src.__support.arg_list
 )
+
+target_link_libraries(libc.test.src.stdio.printf_core.parser_test PRIVATE LibcPrintfHelpers)

libc/test/src/stdio/printf_core/parser_test.cpp

 //===-- Unittests for the printf Parser -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/CPP/Bit.h"
 #include "src/__support/arg_list.h"
 #include "src/stdio/printf_core/parser.h"
 
 #include <stdarg.h>
 
+#include "utils/UnitTest/PrintfMatcher.h"
 #include "utils/UnitTest/Test.h"
 
-class LlvmLibcPrintfParserTest : public __llvm_libc::testing::Test {
-public:
-  void assert_eq_fs(__llvm_libc::printf_core::FormatSection expected,
-                    __llvm_libc::printf_core::FormatSection actual) {
-    ASSERT_EQ(expected.has_conv, actual.has_conv);
-    ASSERT_EQ(expected.raw_len, actual.raw_len);
-
-    for (size_t i = 0; i < expected.raw_len; ++i) {
-      EXPECT_EQ(expected.raw_string[i], actual.raw_string[i]);
-    }
-
-    if (expected.has_conv) {
-      ASSERT_EQ(static_cast<uint8_t>(expected.flags),
-                static_cast<uint8_t>(actual.flags));
-      ASSERT_EQ(expected.min_width, actual.min_width);
-      ASSERT_EQ(expected.precision, actual.precision);
-      ASSERT_TRUE(expected.length_modifier == actual.length_modifier);
-      ASSERT_EQ(expected.conv_name, actual.conv_name);
-
-      if (expected.conv_name == 'p' || expected.conv_name == 'n' ||
-          expected.conv_name == 's') {
-        ASSERT_EQ(expected.conv_val_ptr, actual.conv_val_ptr);
-      } else if (expected.conv_name != '%') {
-        ASSERT_EQ(expected.conv_val_raw, actual.conv_val_raw);
-      }
-    }
-  }
-};
-
 void init(const char *__restrict str, ...) {
   va_list vlist;
   va_start(vlist, str);
   __llvm_libc::internal::ArgList v(vlist);
   va_end(vlist);
 
   __llvm_libc::printf_core::Parser parser(str, v);
 }
void evaluate(__llvm_libc::printf_core::FormatSection *format_arr,
 
   for (auto cur_section = parser.get_next_section(); cur_section.raw_len > 0;
        cur_section = parser.get_next_section()) {
     *format_arr = cur_section;
     ++format_arr;
   }
 }
 
-TEST_F(LlvmLibcPrintfParserTest, Constructor) { init("test", 1, 2); }
+TEST(LlvmLibcPrintfParserTest, Constructor) { init("test", 1, 2); }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalRaw) {
+TEST(LlvmLibcPrintfParserTest, EvalRaw) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "test";
   evaluate(format_arr, str);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = false;
   expected.raw_len = 4;
   expected.raw_string = str;
 
-  assert_eq_fs(expected, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalSimple) {
+TEST(LlvmLibcPrintfParserTest, EvalSimple) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "test %% test";
   evaluate(format_arr, str);
 
   __llvm_libc::printf_core::FormatSection expected0, expected1, expected2;
   expected0.has_conv = false;
   expected0.raw_len = 5;
   expected0.raw_string = str;
 
-  assert_eq_fs(expected0, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected0, format_arr[0]);
 
   expected1.has_conv = true;
   expected1.raw_len = 2;
   expected1.raw_string = str + 5;
   expected1.conv_name = '%';
 
-  assert_eq_fs(expected1, format_arr[1]);
+  ASSERT_FORMAT_EQ(expected1, format_arr[1]);
 
   expected2.has_conv = false;
   expected2.raw_len = 5;
   expected2.raw_string = str + 7;
 
-  assert_eq_fs(expected2, format_arr[2]);
+  ASSERT_FORMAT_EQ(expected2, format_arr[2]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalOneArg) {
+TEST(LlvmLibcPrintfParserTest, EvalOneArg) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
   expected.raw_len = 2;
   expected.raw_string = str;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
-  assert_eq_fs(expected, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalOneArgWithFlags) {
+TEST(LlvmLibcPrintfParserTest, EvalOneArgWithFlags) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%+-0 #d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
   expected.raw_len = 7;
   expected.raw_string = str;
   expected.flags = static_cast<__llvm_libc::printf_core::FormatFlags>(
       __llvm_libc::printf_core::FormatFlags::FORCE_SIGN |
       __llvm_libc::printf_core::FormatFlags::LEFT_JUSTIFIED |
       __llvm_libc::printf_core::FormatFlags::LEADING_ZEROES |
       __llvm_libc::printf_core::FormatFlags::SPACE_PREFIX |
       __llvm_libc::printf_core::FormatFlags::ALTERNATE_FORM);
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
-  assert_eq_fs(expected, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalOneArgWithWidth) {
+TEST(LlvmLibcPrintfParserTest, EvalOneArgWithWidth) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%12d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
   expected.raw_len = 4;
   expected.raw_string = str;
   expected.min_width = 12;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
-  assert_eq_fs(expected, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalOneArgWithPrecision) {
+TEST(LlvmLibcPrintfParserTest, EvalOneArgWithPrecision) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%.34d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
   expected.raw_len = 5;
   expected.raw_string = str;
   expected.precision = 34;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
-  assert_eq_fs(expected, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalOneArgWithTrivialPrecision) {
+TEST(LlvmLibcPrintfParserTest, EvalOneArgWithTrivialPrecision) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%.d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
   expected.raw_len = 3;
   expected.raw_string = str;
   expected.precision = 0;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
-  assert_eq_fs(expected, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalOneArgWithShortLengthModifier) {
+TEST(LlvmLibcPrintfParserTest, EvalOneArgWithShortLengthModifier) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%hd";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
   expected.raw_len = 3;
   expected.raw_string = str;
   expected.length_modifier = __llvm_libc::printf_core::LengthModifier::h;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
-  assert_eq_fs(expected, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalOneArgWithLongLengthModifier) {
+TEST(LlvmLibcPrintfParserTest, EvalOneArgWithLongLengthModifier) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%lld";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
   expected.raw_len = 4;
   expected.raw_string = str;
   expected.length_modifier = __llvm_libc::printf_core::LengthModifier::ll;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
-  assert_eq_fs(expected, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalOneArgWithAllOptions) {
+TEST(LlvmLibcPrintfParserTest, EvalOneArgWithAllOptions) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "% -056.78jd";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = true;
   expected.raw_len = 11;
   expected.raw_string = str;
   expected.flags = static_cast<__llvm_libc::printf_core::FormatFlags>(
       __llvm_libc::printf_core::FormatFlags::LEFT_JUSTIFIED |
       __llvm_libc::printf_core::FormatFlags::LEADING_ZEROES |
       __llvm_libc::printf_core::FormatFlags::SPACE_PREFIX);
   expected.min_width = 56;
   expected.precision = 78;
   expected.length_modifier = __llvm_libc::printf_core::LengthModifier::j;
   expected.conv_val_raw = arg1;
   expected.conv_name = 'd';
 
-  assert_eq_fs(expected, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected, format_arr[0]);
 }
 
-TEST_F(LlvmLibcPrintfParserTest, EvalThreeArgs) {
+TEST(LlvmLibcPrintfParserTest, EvalThreeArgs) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%d%f%s";
   int arg1 = 12345;
   double arg2 = 123.45;
   const char *arg3 = "12345";
   evaluate(format_arr, str, arg1, arg2, arg3);
 
   __llvm_libc::printf_core::FormatSection expected0, expected1, expected2;
   expected0.has_conv = true;
   expected0.raw_len = 2;
   expected0.raw_string = str;
   expected0.conv_val_raw = arg1;
   expected0.conv_name = 'd';
 
-  assert_eq_fs(expected0, format_arr[0]);
+  ASSERT_FORMAT_EQ(expected0, format_arr[0]);
 
   expected1.has_conv = true;
   expected1.raw_len = 2;
   expected1.raw_string = str + 2;
   expected1.conv_val_raw = __llvm_libc::bit_cast<uint64_t>(arg2);
   expected1.conv_name = 'f';
 
-  assert_eq_fs(expected1, format_arr[1]);
+  ASSERT_FORMAT_EQ(expected1, format_arr[1]);
 
   expected2.has_conv = true;
   expected2.raw_len = 2;
   expected2.raw_string = str + 4;
   expected2.conv_val_ptr = const_cast<char *>(arg3);
   expected2.conv_name = 's';
 
-  assert_eq_fs(expected2, format_arr[2]);
+  ASSERT_FORMAT_EQ(expected2, format_arr[2]);
 }

libc/utils/UnitTest/CMakeLists.txt

add_library(
   LibcUnitTestMain
   LibcTestMain.cpp
 )
 
 target_include_directories(LibcUnitTestMain PUBLIC ${LIBC_SOURCE_DIR})
 add_dependencies(LibcUnitTestMain LibcUnitTest)
 target_link_libraries(LibcUnitTestMain PUBLIC LibcUnitTest libc_test_utils)
 
 add_library(
+  LibcTestStringUtils
+  StringUtils.h
+  StringUtils.cpp
+)
+target_include_directories(LibcTestStringUtils PUBLIC ${LIBC_SOURCE_DIR})
+add_dependencies(
+  LibcTestStringUtils
+  libc.src.__support.CPP.type_traits
+)
+
+add_library(
   LibcFPTestHelpers
     FPExceptMatcher.cpp
     FPExceptMatcher.h
     FPMatcher.cpp
     FPMatcher.h
 )
 target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
 target_link_libraries(LibcFPTestHelpers LibcUnitTest)
 add_dependencies(
   LibcFPTestHelpers
   LibcUnitTest
+  LibcTestStringUtils
   libc.src.__support.FPUtil.fputil
 )
 
 add_library(
   LibcMemoryHelpers
     MemoryMatcher.h
     MemoryMatcher.cpp
 )
 target_include_directories(LibcMemoryHelpers PUBLIC ${LIBC_SOURCE_DIR})
 target_link_libraries(LibcMemoryHelpers LibcUnitTest)
 add_dependencies(
   LibcMemoryHelpers
   LibcUnitTest
   libc.src.__support.CPP.array_ref
 )
+
+add_library(
+  LibcPrintfHelpers
+    PrintfMatcher.h
+    PrintfMatcher.cpp
+)
+target_include_directories(LibcPrintfHelpers PUBLIC ${LIBC_SOURCE_DIR})
+target_link_libraries(LibcPrintfHelpers LibcUnitTest)
+add_dependencies(
+  LibcPrintfHelpers
+  LibcUnitTest
+  LibcTestStringUtils
+  libc.src.stdio.printf_core.core_structs
+)

libc/utils/UnitTest/FPMatcher.cpp

 //===-- TestMatchers.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "FPMatcher.h"
 
 #include "src/__support/FPUtil/FPBits.h"
 
+#include "utils/UnitTest/StringUtils.h"
+
 #include <sstream>
 #include <string>
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
-// Return the first N hex digits of an integer as a string in upper case.
-template <typename T>
-cpp::EnableIfType<cpp::IsIntegral<T>::Value, std::string>
-uintToHex(T X, size_t Length = sizeof(T) * 2) {
-  std::string s(Length, '0');
-
-  for (auto it = s.rbegin(), end = s.rend(); it != end; ++it, X >>= 4) {
-    unsigned char Mod = static_cast<unsigned char>(X) & 15;
-    *it = (Mod < 10 ? '0' + Mod : 'a' + Mod - 10);
-  }
-
-  return s;
-}
-
 template <typename ValType, typename StreamType>
 cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, void>
 describeValue(const char *label, ValType value, StreamType &stream) {
   stream << label;
 
   FPBits<ValType> bits(value);
   if (bits.is_nan()) {
     stream << "(NaN)";
   } else if (bits.is_inf()) {
     if (bits.get_sign())
       stream << "(-Infinity)";
     else
       stream << "(+Infinity)";
   } else {
     constexpr int exponentWidthInHex =
         (fputil::ExponentWidth<ValType>::VALUE - 1) / 4 + 1;
     constexpr int mantissaWidthInHex =
         (fputil::MantissaWidth<ValType>::VALUE - 1) / 4 + 1;
     constexpr int bitsWidthInHex =
         sizeof(typename fputil::FPBits<ValType>::UIntType) * 2;
 
     stream << "0x"
-           << uintToHex<typename fputil::FPBits<ValType>::UIntType>(
+           << int_to_hex<typename fputil::FPBits<ValType>::UIntType>(
                   bits.uintval(), bitsWidthInHex)
            << ", (S | E | M) = (" << (bits.get_sign() ? '1' : '0') << " | 0x"
-           << uintToHex<uint16_t>(bits.get_unbiased_exponent(),
+           << int_to_hex<uint16_t>(bits.get_unbiased_exponent(),
                                    exponentWidthInHex)
            << " | 0x"
-           << uintToHex<typename fputil::FPBits<ValType>::UIntType>(
+           << int_to_hex<typename fputil::FPBits<ValType>::UIntType>(
                   bits.get_mantissa(), mantissaWidthInHex)
            << ")";
   }
 
   stream << '\n';
 }
 
 template void describeValue<float>(const char *, float,

libc/utils/UnitTest/PrintfMatcher.h

+//===-- PrintfMatcher.h -----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_UTILS_UNITTEST_PRINTF_MATCHER_H
+#define LLVM_LIBC_UTILS_UNITTEST_PRINTF_MATCHER_H
+
+#include "src/stdio/printf_core/core_structs.h"
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+
+namespace __llvm_libc {
+namespace printf_core {
+namespace testing {
+
+class FormatSectionMatcher
+    : public __llvm_libc::testing::Matcher<FormatSection> {
+  FormatSection expected;
+  FormatSection actual;
+
+public:
+  FormatSectionMatcher(FormatSection expectedValue) : expected(expectedValue) {}
+
+  bool match(FormatSection actualValue);
+
+  void explainError(testutils::StreamWrapper &stream) override;
+};
+
+} // namespace testing
+} // namespace printf_core
+} // namespace __llvm_libc
+
+#define EXPECT_FORMAT_EQ(expected, actual)                                     \
+  EXPECT_THAT(actual, __llvm_libc::printf_core::testing::FormatSectionMatcher( \
+                          expected))
+
+#define ASSERT_FORMAT_EQ(expected, actual)                                     \
+  ASSERT_THAT(actual, __llvm_libc::printf_core::testing::FormatSectionMatcher( \
+                          expected))
+
+#endif // LLVM_LIBC_UTILS_UNITTEST_PRINTF_MATCHER_H

libc/utils/UnitTest/PrintfMatcher.cpp

+//===-- PrintfMatcher.cpp ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "PrintfMatcher.h"
+#include "src/stdio/printf_core/core_structs.h"
+
+#include "utils/UnitTest/StringUtils.h"
+
+#include <stdint.h>
+
+namespace __llvm_libc {
+namespace printf_core {
+namespace testing {
+
+bool FormatSectionMatcher::match(FormatSection actualValue) {
+  actual = actualValue;
+  return expected == actual;
+}
+
+namespace {
+
+#define IF_FLAG_SHOW_FLAG(flag_name)                                           \
+  do {                                                                         \
+    if ((form.flags & FormatFlags::flag_name) == FormatFlags::flag_name)       \
+      stream << "\n\t\t" << #flag_name;                                        \
+  } while (false)
+#define CASE_LM(lm)                                                            \
+  case (LengthModifier::lm):                                                   \
+    stream << #lm;                                                             \
+    break
+
+void display(testutils::StreamWrapper &stream, FormatSection form) {
+  stream << "Raw String (len " << form.raw_len << "): \"";
+  for (size_t i = 0; i < form.raw_len; ++i) {
+    stream << form.raw_string[i];
+  }
+  stream << "\"";
+  if (form.has_conv) {
+    stream << "\n\tHas Conv\n\tFlags:";
+    IF_FLAG_SHOW_FLAG(LEFT_JUSTIFIED);
+    IF_FLAG_SHOW_FLAG(FORCE_SIGN);
+    IF_FLAG_SHOW_FLAG(SPACE_PREFIX);
+    IF_FLAG_SHOW_FLAG(ALTERNATE_FORM);
+    IF_FLAG_SHOW_FLAG(LEADING_ZEROES);
+    stream << "\n";
+    stream << "\tmin width: " << form.min_width << "\n";
+    stream << "\tprecision: " << form.precision << "\n";
+    stream << "\tlength modifier: ";
+    switch (form.length_modifier) {
+      CASE_LM(none);
+      CASE_LM(l);
+      CASE_LM(ll);
+      CASE_LM(h);
+      CASE_LM(hh);
+      CASE_LM(j);
+      CASE_LM(z);
+      CASE_LM(t);
+      CASE_LM(L);
+    }
+    stream << "\n";
+    stream << "\tconversion name: " << form.conv_name << "\n";
+    if (form.conv_name == 'p' || form.conv_name == 'n' || form.conv_name == 's')
+      stream << "\tpointer value: "
+             << int_to_hex<uintptr_t>(
+                    reinterpret_cast<uintptr_t>(form.conv_val_ptr))
+             << "\n";
+    else if (form.conv_name != '%')
+      stream << "\tvalue: " << int_to_hex<__uint128_t>(form.conv_val_raw)
+             << "\n";
+  }
+}
+} // anonymous namespace
+
+void FormatSectionMatcher::explainError(testutils::StreamWrapper &stream) {
+  stream << "expected format section: ";
+  display(stream, expected);
+  stream << '\n';
+  stream << "actual format section  : ";
+  display(stream, actual);
+  stream << '\n';
+}
+
+} // namespace testing
+} // namespace printf_core
+} // namespace __llvm_libc

libc/utils/UnitTest/StringUtils.h

+//===-- String utils for matchers -------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H
+#define LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H
+
+#include "src/__support/CPP/TypeTraits.h"
+
+#include <string>
+
+namespace __llvm_libc {
+
+// Return the first N hex digits of an integer as a string in upper case.
+template <typename T>
+cpp::EnableIfType<cpp::IsIntegral<T>::Value, std::string>
+int_to_hex(T X, size_t Length = sizeof(T) * 2) {
+  std::string s(Length, '0');
+
+  for (auto it = s.rbegin(), end = s.rend(); it != end; ++it, X >>= 4) {
+    unsigned char Mod = static_cast<unsigned char>(X) & 15;
+    *it = (Mod < 10 ? '0' + Mod : 'a' + Mod - 10);
+  }
+
+  return s;
+}
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_UTILS_UNITTEST_SIMPLE_STRING_CONV_H

libc/utils/UnitTest/StringUtils.cpp

+//===-- String util implementations for matchers ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "StringUtils.h"
+
+namespace __llvm_libc {
+
+// This file exists for future expansion and also so that CMake understands that
+// StringUtils.h is a cpp file and not a C file.
+
+} // namespace __llvm_libc