[Support] Add a GTest matcher for Optional<T>

[sammccall]

llvm/include/llvm/Testing/Support/SupportHelpers.h

65

AFAICS from other helpers, ValueIsMatcher should go in llvm::detail, and ValueIs should go in llvm.

unittest::getInputFileDirectory() reads well, but unittest::ValueIs(...) really doesn't...

85

is this actually necessary? I think it's already going to print the value, which is always "None" - I'm not sure "None, which does not have a value" is clearer.

109

it's a shame the name HasValue is taken, as I think it would much more clearly communicate "has a value *and* the value is...".

[ilya-biryukov]

• Move matcher class to llvm::detail, factory function to llvm
• Add a simple test

[ilya-biryukov]

llvm/include/llvm/Testing/Support/SupportHelpers.h

65

Agreed.

85

Agree, that should be fine

109

Totally agree, couldn't come up with a better name that wasn't taken.

llvm/include/llvm/Testing/Support/SupportHelpers.h

 //===- Testing/Support/SupportHelpers.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_SUPPORT_SUPPORTHELPERS_H
 #define LLVM_TESTING_SUPPORT_SUPPORTHELPERS_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_os_ostream.h"
+#include "gmock/gmock-matchers.h"
 #include "gtest/gtest-printers.h"
 
 #include <string>
 
 namespace llvm {
 namespace detail {
 struct ErrorHolder {
   std::vector<std::shared_ptr<ErrorInfoBase>> Infos;
void PrintTo(const ExpectedHolder<T> &Item, std::ostream *Out) {
   } else {
     PrintTo(static_cast<const ErrorHolder &>(Item), Out);
   }
 }
 } // namespace detail
 
 namespace unittest {
 SmallString<128> getInputFileDirectory(const char *Argv0);
+
+/// Matches an llvm::Optional<T> with a value that conforms to an inner matcher.
+/// To match llvm::None you could use Eq(llvm::None).
+template <class InnerMatcher> class ValueIsMatcher {
+public:
+  explicit ValueIsMatcher(InnerMatcher ValueMatcher)
+      : ValueMatcher(ValueMatcher) {}
+
+  template <class T>
+  operator ::testing::Matcher<const llvm::Optional<T> &>() const {
+    return ::testing::MakeMatcher(
+        new Impl<T>(::testing::SafeMatcherCast<T>(ValueMatcher)));
+  }
+
+  template <class T>
+  class Impl : public ::testing::MatcherInterface<const llvm::Optional<T> &> {
+  public:
+    explicit Impl(const ::testing::Matcher<T> &ValueMatcher)
+        : ValueMatcher(ValueMatcher) {}
+
+    bool MatchAndExplain(const llvm::Optional<T> &Input,
+                         testing::MatchResultListener *L) const override {
+      if (!Input) {
+        *L << "does not have a value";
+        return false;
+      }
+      return ValueMatcher.MatchAndExplain(Input.getValue(), L);
+    }
+
+    void DescribeTo(std::ostream *OS) const override {
+      *OS << "has a value that ";
+      ValueMatcher.DescribeTo(OS);
+    }
+    void DescribeNegationTo(std::ostream *OS) const override {
+      *OS << "does not have a value that ";
+      ValueMatcher.DescribeTo(OS);
+    }
+
+  private:
+    testing::Matcher<T> ValueMatcher;
+  };
+
+private:
+  InnerMatcher ValueMatcher;
+};
+
+template <class InnerMatcher>
+ValueIsMatcher<InnerMatcher> ValueIs(const InnerMatcher &ValueMatcher) {
+  return ValueIsMatcher<InnerMatcher>(ValueMatcher);
 }
+} // namespace unittest
 } // namespace llvm
 
 #endif