[Testing/Support] Make matchers work with Expected<T&>

[labath]

Summary

This did not work because the ExpectedHolder was trying to hold the
value in an Optional<T*>. Instead of trying to mimic the behavior of
Expected and try to make ExpectedHolder work with references and
non-references, I simply store the reference to the Expected object in
the holder.

I also add a bunch of tests for these matchers, which have helped me
flesh out some problems in my initial implementation of this patch, and
uncovered the fact that we are not consistent in quoting our values in
the matcher output (which I also fix).

llvm/trunk/include/llvm/Testing/Support/Error.h

 #include "gmock/gmock.h"
 #include <ostream>
 
 namespace llvm {
 namespace detail {
 ErrorHolder TakeError(Error Err);
 
 template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &Exp) {
-  llvm::detail::ExpectedHolder<T> Result;
-  auto &EH = static_cast<llvm::detail::ErrorHolder &>(Result);
-  EH = TakeError(Exp.takeError());
-  if (Result.Success)
-    Result.Value = &(*Exp);
-  return Result;
+  return {TakeError(Exp.takeError()), Exp};
 }
 
 template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &&Exp) {
   return TakeExpected(Exp);
 }
 } // namespace detail
 
 #define EXPECT_THAT_ERROR(Err, Matcher)                                        \
   EXPECT_THAT(llvm::detail::TakeError(Err), Matcher)
 #define ASSERT_THAT_ERROR(Err, Matcher)                                        \
   ASSERT_THAT(llvm::detail::TakeError(Err), Matcher)
 
 #define EXPECT_THAT_EXPECTED(Err, Matcher)                                     \
   EXPECT_THAT(llvm::detail::TakeExpected(Err), Matcher)
 #define ASSERT_THAT_EXPECTED(Err, Matcher)                                     \
   ASSERT_THAT(llvm::detail::TakeExpected(Err), Matcher)
 
 MATCHER(Succeeded, "") { return arg.Success; }
 MATCHER(Failed, "") { return !arg.Success; }
 
 MATCHER_P(HasValue, value,
-          "succeeded with value " + testing::PrintToString(value)) {
+          "succeeded with value \"" + testing::PrintToString(value) + '"') {
   if (!arg.Success) {
     *result_listener << "operation failed";
     return false;
   }
 
-  assert(arg.Value.hasValue());
-  if (**arg.Value != value) {
-    *result_listener << "but \"" + testing::PrintToString(**arg.Value) +
-                            "\" != " + testing::PrintToString(value);
+  if (*arg.Exp != value) {
+    *result_listener << "but \"" + testing::PrintToString(*arg.Exp) +
+                            "\" != \"" + testing::PrintToString(value) + '"';
     return false;
   }
 
   return true;
 }
 } // namespace llvm
 
 #endif

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

 namespace llvm {
 namespace detail {
 struct ErrorHolder {
   bool Success;
   std::string Message;
 };
 
 template <typename T> struct ExpectedHolder : public ErrorHolder {
-  Optional<T *> Value;
+  ExpectedHolder(ErrorHolder Err, Expected<T> &Exp)
+      : ErrorHolder(std::move(Err)), Exp(Exp) {}
+
+  Expected<T> &Exp;
 };
 
 inline void PrintTo(const ErrorHolder &Err, std::ostream *Out) {
   *Out << (Err.Success ? "succeeded" : "failed");
   if (!Err.Success) {
     *Out << "  (" << StringRef(Err.Message).trim().str() << ")";
   }
 }
 
 template <typename T>
 void PrintTo(const ExpectedHolder<T> &Item, std::ostream *Out) {
   if (Item.Success) {
-    *Out << "succeeded with value \"" << ::testing::PrintToString(**Item.Value)
+    *Out << "succeeded with value \"" << ::testing::PrintToString(*Item.Exp)
          << "\"";
   } else {
     PrintTo(static_cast<const ErrorHolder &>(Item), Out);
   }
 }
 } // namespace detail
 } // namespace llvm
 
 #endif

llvm/trunk/unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   YAMLParserTest.cpp
   formatted_raw_ostream_test.cpp
   raw_ostream_test.cpp
   raw_pwrite_stream_test.cpp
   raw_sha1_ostream_test.cpp
   xxhashTest.cpp
   )
 
+target_link_libraries(SupportTests PRIVATE LLVMTestingSupport)
+
 # Disable all warning for AlignOfTest.cpp,
 # as it does things intentionally, and there is no reliable way of
 # disabling all warnings for all the compilers by using pragmas.
 set_source_files_properties(AlignOfTest.cpp PROPERTIES COMPILE_FLAGS -w)
 
 # ManagedStatic.cpp uses <pthread>.
 target_link_libraries(SupportTests PRIVATE LLVMTestingSupport ${LLVM_PTHREAD_LIB})
 
 add_subdirectory(DynamicLibrary)

llvm/trunk/unittests/Support/ErrorTest.cpp

 //===----- unittests/ErrorTest.cpp - Error.h tests ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Error.h"
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 using namespace llvm;
 
 namespace {
 
 // Custom error class with a default base class and some random 'info' attached.
TEST(Error, ErrorMessage) {
 
   Error E3 = joinErrors(make_error<CustomError>(0), make_error<CustomError>(1));
   EXPECT_EQ(toString(std::move(E3))
                 .compare("CustomError { 0}\n"
                          "CustomError { 1}"),
             0);
 }
 
+TEST(Error, ErrorMatchers) {
+  EXPECT_THAT_ERROR(Error::success(), Succeeded());
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THAT_ERROR(make_error<CustomError>(0), Succeeded()),
+      "Expected: succeeded\n  Actual: failed  (CustomError { 0})");
+
+  EXPECT_THAT_ERROR(make_error<CustomError>(0), Failed());
+  EXPECT_NONFATAL_FAILURE(EXPECT_THAT_ERROR(Error::success(), Failed()),
+                          "Expected: failed\n  Actual: succeeded");
+
+  EXPECT_THAT_EXPECTED(Expected<int>(0), Succeeded());
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THAT_EXPECTED(Expected<int>(make_error<CustomError>(0)),
+                           Succeeded()),
+      "Expected: succeeded\n  Actual: failed  (CustomError { 0})");
+
+  EXPECT_THAT_EXPECTED(Expected<int>(make_error<CustomError>(0)), Failed());
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THAT_EXPECTED(Expected<int>(0), Failed()),
+      "Expected: failed\n  Actual: succeeded with value \"0\"");
+
+  EXPECT_THAT_EXPECTED(Expected<int>(0), HasValue(0));
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THAT_EXPECTED(Expected<int>(make_error<CustomError>(0)),
+                           HasValue(0)),
+      "Expected: succeeded with value \"0\"\n"
+      "  Actual: failed  (CustomError { 0})");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THAT_EXPECTED(Expected<int>(1), HasValue(0)),
+      "Expected: succeeded with value \"0\"\n"
+      "  Actual: succeeded with value \"1\", but \"1\" != \"0\"");
+
+  EXPECT_THAT_EXPECTED(Expected<int &>(make_error<CustomError>(0)), Failed());
+  int a = 1;
+  EXPECT_THAT_EXPECTED(Expected<int &>(a), Succeeded());
+  EXPECT_THAT_EXPECTED(Expected<int &>(a), HasValue(1));
+}
+
 } // end anon namespace