[llvm][Testing/ADT] Implement `IsStringMapEntry` testing matcher for verifying the entries in a `StringMap`.

[wyt]

Summary

Depends on D132747

[gribozavr2]

llvm/include/llvm/ADT/StringMapEntry.h

104

llvm/include/llvm/Testing/ADT/StringMapEntryMatcher.h

20–21

llvm/unittests/Testing/ADT/StringMapEntryMatcherTest.cpp

58

Unused variable?

llvm/unittests/Testing/CMakeLists.txt

1–2

Please sort.

utils/bazel/llvm-project-overlay/llvm/BUILD.bazel

4178

Could you put it right before TestingSupport (below), and call it TestingADT (to follow the existing camel case naming convention)?

[wyt]

Address comments.

[gribozavr2]

Did you accidentally revert the Bazel build files with the last update? LGTM otherwise.

[wyt]

In D132753#3758163, @gribozavr2 wrote:

Did you accidentally revert the Bazel build files with the last update? LGTM otherwise.

The build files are now created in the parent patch (https://reviews.llvm.org/D132747) since the implementation for << has been moved into Testing/ADT.

[wyt]

utils/bazel/llvm-project-overlay/llvm/BUILD.bazel

4178

Creation of the bazel target is moved to parent patch, and renaming has been updated there.

[gribozavr2]

Ah, I see, I didn't realize that other patch was a parent to this one.

[wyt]

Update build target.

llvm/include/llvm/ADT/StringMapEntry.h

 };
 
 /// StringMapEntry - This is used to represent one value that is inserted into
 /// a StringMap.  It contains the Value itself and the key: the string length
 /// and data.
 template <typename ValueTy>
 class StringMapEntry final : public StringMapEntryStorage<ValueTy> {
 public:
+  typedef ValueTy ValueType;
+
   using StringMapEntryStorage<ValueTy>::StringMapEntryStorage;
 
   StringRef getKey() const {
     return StringRef(getKeyData(), this->getKeyLength());
   }
 
   /// getKeyData - Return the start of the string data that is the key for this
   /// value.  The string data is always stored immediately after the

llvm/include/llvm/Testing/ADT/StringMapEntryMatcher.h

+//===- llvm/Testing/Support/StringMapEntryMatcher.h -----------------------===//
+//
+// 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_TESTING_ADT_STRINGMAPENTRYMATCHER_H_
+#define LLVM_TESTING_ADT_STRINGMAPENTRYMATCHER_H_
+
+#include "gmock/gmock.h"
+#include <ostream>
+
+namespace llvm {
+template <typename StringMapEntryT>
+class StringMapEntryMatcherImpl
+    : public testing::MatcherInterface<StringMapEntryT> {
+public:
+  typedef
+      typename std::remove_reference<StringMapEntryT>::type::ValueType ValueT;
+
+  template <typename KeyMatcherT, typename ValueMatcherT>
+  StringMapEntryMatcherImpl(KeyMatcherT KeyMatcherArg,
+                            ValueMatcherT ValueMatcherArg)
+      : KeyMatcher(
+            testing::SafeMatcherCast<const std::string &>(KeyMatcherArg)),
+        ValueMatcher(
+            testing::SafeMatcherCast<const ValueT &>(ValueMatcherArg)) {}
+
+  void DescribeTo(std::ostream *OS) const override {
+    *OS << "has a string key that ";
+    KeyMatcher.DescribeTo(OS);
+    *OS << ", and has a value that ";
+    ValueMatcher.DescribeTo(OS);
+  }
+
+  void DescribeNegationTo(std::ostream *OS) const override {
+    *OS << "has a string key that ";
+    KeyMatcher.DescribeNegationTo(OS);
+    *OS << ", or has a value that ";
+    ValueMatcher.DescribeNegationTo(OS);
+  }
+
+  bool
+  MatchAndExplain(StringMapEntryT Entry,
+                  testing::MatchResultListener *ResultListener) const override {
+    testing::StringMatchResultListener KeyListener;
+    if (!KeyMatcher.MatchAndExplain(Entry.getKey().data(), &KeyListener)) {
+      *ResultListener << ("which has a string key " +
+                          (KeyListener.str().empty() ? "that doesn't match"
+                                                     : KeyListener.str()));
+      return false;
+    }
+    testing::StringMatchResultListener ValueListener;
+    if (!ValueMatcher.MatchAndExplain(Entry.getValue(), &ValueListener)) {
+      *ResultListener << ("which has a value " + (ValueListener.str().empty()
+                                                      ? "that doesn't match"
+                                                      : ValueListener.str()));
+      return false;
+    }
+    *ResultListener << "which is a match";
+    return true;
+  }
+
+private:
+  const testing::Matcher<const std::string &> KeyMatcher;
+  const testing::Matcher<const ValueT &> ValueMatcher;
+};
+
+template <typename KeyMatcherT, typename ValueMatcherT>
+class StringMapEntryMatcher {
+public:
+  StringMapEntryMatcher(KeyMatcherT KMArg, ValueMatcherT VMArg)
+      : KM(std::move(KMArg)), VM(std::move(VMArg)) {}
+
+  template <typename StringMapEntryT>
+  operator testing::Matcher<StringMapEntryT>() const { // NOLINT
+    return testing::Matcher<StringMapEntryT>(
+        new StringMapEntryMatcherImpl<const StringMapEntryT &>(KM, VM));
+  }
+
+private:
+  const KeyMatcherT KM;
+  const ValueMatcherT VM;
+};
+
+/// Returns a gMock matcher that matches a `StringMapEntry` whose string key
+/// matches `KeyMatcher`, and whose value matches `ValueMatcher`.
+template <typename KeyMatcherT, typename ValueMatcherT>
+StringMapEntryMatcher<KeyMatcherT, ValueMatcherT>
+IsStringMapEntry(KeyMatcherT KM, ValueMatcherT VM) {
+  return StringMapEntryMatcher<KeyMatcherT, ValueMatcherT>(std::move(KM),
+                                                           std::move(VM));
+}
+
+} // namespace llvm
+
+#endif

llvm/unittests/Testing/ADT/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Support
+  )
+
+add_llvm_unittest(TestingADTTests
+  StringMapEntryMatcherTest.cpp
+  )

llvm/unittests/Testing/ADT/StringMapEntryMatcherTest.cpp

+//===- StringMapEntryMatcherTest.cpp --------------------------------------===//
+//
+// 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/Testing/ADT/StringMapEntryMatcher.h"
+#include "llvm/ADT/StringMap.h"
+
+#include "gtest/gtest.h"
+#include <sstream>
+
+namespace llvm {
+namespace {
+
+using testing::Gt;
+using testing::Matcher;
+using testing::StrCaseEq;
+using testing::StringMatchResultListener;
+using testing::UnorderedElementsAre;
+
+template <typename T> std::string Describe(const Matcher<T> &M, bool Match) {
+  std::stringstream SS;
+  if (Match) {
+    M.DescribeTo(&SS);
+  } else {
+    M.DescribeNegationTo(&SS);
+  }
+  return SS.str();
+}
+
+template <typename T, typename V>
+std::string ExplainMatch(const Matcher<T> &Matcher, const V &Value) {
+  StringMatchResultListener Listener;
+  Matcher.MatchAndExplain(Value, &Listener);
+  return Listener.str();
+}
+
+TEST(IsStringMapEntryTest, InnerMatchersAreExactValues) {
+  llvm::StringMap<int> Map = {{"A", 1}};
+  EXPECT_THAT(*Map.find("A"), IsStringMapEntry("A", 1));
+}
+
+TEST(IsStringMapEntryTest, InnerMatchersAreOtherMatchers) {
+  llvm::StringMap<int> Map = {{"A", 1}};
+  EXPECT_THAT(*Map.find("A"), IsStringMapEntry(StrCaseEq("a"), Gt(0)));
+}
+
+TEST(IsStringMapEntryTest, UseAsInnerMatcher) {
+  llvm::StringMap<int> Map = {{"A", 1}, {"B", 2}};
+  EXPECT_THAT(Map, UnorderedElementsAre(IsStringMapEntry("A", 1),
+                                        IsStringMapEntry("B", 2)));
+}
+
+TEST(IsStringMapEntryTest, DescribeSelf) {
+  llvm::StringMap<int> Map = {{"A", 1}};
+  Matcher<llvm::StringMapEntry<int>> M = IsStringMapEntry("A", 1);
+  EXPECT_EQ(
+      R"(has a string key that is equal to "A", and has a value that is equal to 1)",
+      Describe(M, true));
+  EXPECT_EQ(
+      R"(has a string key that isn't equal to "A", or has a value that isn't equal to 1)",
+      Describe(M, false));
+}
+
+TEST(IsStringMapEntryTest, ExplainSelfMatchSuccess) {
+  llvm::StringMap<int> Map = {{"A", 1}};
+  Matcher<llvm::StringMapEntry<int>> M = IsStringMapEntry("A", 1);
+  EXPECT_EQ(R"(which is a match)", ExplainMatch(M, *Map.find("A")));
+}
+
+TEST(IsStringMapEntryTest, ExplainSelfMatchFailsOnKey) {
+  llvm::StringMap<int> Map = {{"B", 1}};
+  Matcher<llvm::StringMapEntry<int>> M = IsStringMapEntry("A", 1);
+  EXPECT_EQ(R"(which has a string key that doesn't match)",
+            ExplainMatch(M, *Map.find("B")));
+}
+
+TEST(IsStringMapEntryTest, ExplainSelfMatchFailsOnValue) {
+  llvm::StringMap<int> Map = {{"A", 2}};
+  Matcher<llvm::StringMapEntry<int>> M = IsStringMapEntry("A", 1);
+  EXPECT_EQ(R"(which has a value that doesn't match)",
+            ExplainMatch(M, *Map.find("A")));
+}
+
+} // namespace
+} // namespace llvm

llvm/unittests/Testing/CMakeLists.txt

 add_subdirectory(Support)
+add_subdirectory(ADT)

utils/bazel/llvm-project-overlay/llvm/BUILD.bazel

cc_library(
     copts = llvm_copts,
     includes = [
         "include",
         "utils/unittest/googlemock/include",
     ],
     deps = [":gtest"],
 )
 
+cc_library(
+    name = "testing_adt",
+    testonly = True,
+    hdrs = glob([
+        "include/llvm/Testing/ADT/*.h",
+    ]),
+    copts = llvm_copts,
+    deps = [":gmock"],
+)
+
 py_binary(
     name = "lit",
     testonly = True,
     srcs = ["utils/lit/lit.py"] + glob(["utils/lit/lit/**/*.py"]),
 )
 
 cc_library(
     name = "TestingSupport",

utils/bazel/llvm-project-overlay/llvm/unittests/BUILD.bazel

cc_test(
     deps = [
         "//llvm:AArch64CodeGen",
         "//llvm:gtest",
         "//llvm:gtest_main",
     ],
 )
 
 cc_test(
+    name = "testing_adt_tests",
+    size = "small",
+    srcs = glob(
+        [
+            "Testing/ADT/*.cpp",
+        ],
+        allow_empty = False,
+    ),
+    deps = [
+        "//llvm:Support",
+        "//llvm:gtest",
+        "//llvm:gtest_main",
+        "//llvm:testing_adt",
+    ],
+)
+
+cc_test(
     name = "transforms_tests",
     size = "small",
     srcs = glob(
         [
             "Transforms/IPO/*.cpp",
             "Transforms/IPO/*.h",
             "Transforms/Utils/*.cpp",
         ],