[unittest] teach gTest to print entries of DenseMap as pairs

[sammccall]

Summary

When an assertion like the following fails:

EXPECT_THAT(map, ElementsAre(Pair("p", "nullable"))));

Error message before:

Actual: { 40-byte object <E8-A5 9C-7F 25-37 00-00 58-7E 51-51 D0-7F 00-00 00-00 00-00 00-00 00-00 01-00 00-00 00-00 00-00 00-DA C7-7F 25-37 00-00> }

After:

Actual: { ("p", "nonnull") }

It is not ideal that we need to refer directly to DenseMapPair inside the
internal namespace, but I believe the practical maintenance risk is low.
This change is covered by DenseMap's unittests, as we've covered SmallString etc
in the past.

[sammccall]

fix include inside #if

[mboehme]

This is a great quality-of-life improvement!

I agree that the practical risk of referring to DenseMapPair is low. If it ever does change so it no longer inherits from std::pair then, in the worst case, we can remove the PrintTo overload introduced here and be in a no worse position than before. (Preferably, though, we would change the implementation so that it continues to print the same thing.)

third-party/unittest/googletest/include/gtest/internal/custom/gtest-printers.h

74

Is there a reason we can't simply do this?

::testing::PrintTo(static_cast<const std::pair<K, V> &>(Pair), OS);

[sammccall]

third-party/unittest/googletest/include/gtest/internal/custom/gtest-printers.h

74

This does technically work, but it's relying on internals of gtest (it's actually ::testing::detail::PrintTo).

PrintToString is the public API for "print this thing you know how to print", exactly what functions that dispatches to is an implementation detail.

[mboehme]

third-party/unittest/googletest/include/gtest/internal/custom/gtest-printers.h

74

Thanks for the explanation, LGTM!

llvm/unittests/ADT/DenseMapTest.cpp

 //===- llvm/unittest/ADT/DenseMapMap.cpp - DenseMap unit tests --*- 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 "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/DenseMapInfoVariant.h"
+#include "llvm/ADT/StringRef.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <map>
 #include <set>
 #include <utility>
 #include <variant>
 
 using namespace llvm;
TEST(DenseMapCustomTest, VariantSupport) {
   Map.try_emplace(Keys[1], 1);
   EXPECT_THAT(Map, testing::SizeIs(2));
   EXPECT_NE(DenseMapInfo<variant>::getHashValue(Keys[0]),
             DenseMapInfo<variant>::getHashValue(Keys[1]));
   // Check that isEqual dispatches to isEqual of underlying type, and not to
   // operator==.
   EXPECT_FALSE(DenseMapInfo<variant>::isEqual(Keys[2], Keys[2]));
 }
+
+// Test that gTest prints map entries as pairs instead of opaque objects.
+// See third-party/unittest/googletest/internal/custom/gtest-printers.h
+TEST(DenseMapCustomTest, PairPrinting) {
+  DenseMap<int, StringRef> Map = {{1, "one"}, {2, "two"}};
+  EXPECT_EQ(R"({ (1, "one"), (2, "two") })", ::testing::PrintToString(Map));
+}
+
 } // namespace

third-party/unittest/googletest/include/gtest/internal/custom/gtest-printers.h

 // Injection point for custom user configurations. See README for details
 //
 // ** Custom implementation starts here **
 
 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
 #define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
 
 #if !GTEST_NO_LLVM_SUPPORT
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include <ostream>
 // Printing of llvm String types.
 // gtest sees these as containers of char (they have nested iterator types),
 // so their operator<< is never considered unless we provide PrintTo().
 // PrintStringTo provides quotes and escaping, at the cost of a copy.
 namespace llvm {
 inline void PrintTo(llvm::StringRef S, std::ostream *OS) {
   *OS << ::testing::PrintToString(S.str());
 }
 // We need both SmallString<N> and SmallVectorImpl<char> overloads:
 //  - the SmallString<N> template is needed as overload resolution will
 //    instantiate generic PrintTo<T> rather than do derived-to-base conversion
 //  - but SmallVectorImpl<char> is sometimes the actual static type, in code
 //    that erases the small size
 template <unsigned N>
 inline void PrintTo(const SmallString<N> &S, std::ostream *OS) {
   *OS << ::testing::PrintToString(std::string(S.data(), S.size()));
 }
 inline void PrintTo(const SmallVectorImpl<char> &S, std::ostream *OS) {
   *OS << ::testing::PrintToString(std::string(S.data(), S.size()));
 }
+
+// DenseMap's entries inherit from std::pair, and should act like pairs.
+// However gTest's provided `PrintTo(pair<K,V>)` template won't deduce K and V
+// because of the needed derived-to-base conversion.
+namespace detail {
+template <typename K, typename V>
+inline void PrintTo(const DenseMapPair<K, V> &Pair, std::ostream *OS) {
+  *OS << ::testing::PrintToString(static_cast<const std::pair<K, V> &>(Pair));
+}
+} // namespace detail
+
 } // namespace llvm
 #endif // !GTEST_NO_LLVM_SUPPORT
 
 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_