Create an shared include directory for gtest helper functions

[zturner]

Summary

Often different tests in different test executables need to do the same thing. Historically, we have always just copied large blocks of code between tests to solve this. For example, if a function returns an llvm::Error, then we would like to have some set of EXPECT / ASSERT macros that can handle them in the canonical gtest fashion, and these should be shared among all tests. Currently we have no such place to put code of this nature.

This patch adds such a location in llvm/Support/gtest. For now it's header only, but in the future it could be extended to have a library component as well that is force linked into all unittest targets.

Additional use cases of this could include adding asserts and expect macros for std::error_code, or adding various mock objects to be used alongside gmock (think: ASSERT_THAT(ElementExists(Vec, 7)).

In this patch, I take two instances of the same copied file that contains macros for expecting and asserting on llvm::Errors, and move them to this shared directory, then include the shared file.

[zturner]

ping

[chandlerc]

I definitely want this. First question is where?

I don't think this should be under include/llvm because it isn't a public header of LLVM. Nothing in lib/... should use it, etc.

How about utils/unittest/Helpers/Foo.h? We can even add .../Foo.cpp if/when we need it? Then we can just make these headers available similarly to how we make the google test headers available.

[chandlerc]

llvm/include/llvm/gtest/ErrorChecking.h

37 ↗

(On Diff #98507)

I'm fine moving the existing helpers, but before we expand this, i'd like to think about whether its time to write up the doc about good usage of gmock matchers, get folks OK with that, and write this as a library of matchers that work with EXPECT_THAT instead.

[zturner]

Moved the folder. I really would like to put it in utils\unittest\googletest\include\gtest\Support, because then you could write

#include "gtest/gtest.h"
#include "gtest/Support/ErrorChecking.h"

but I'm not sure if sticking our own directory inside of a directory of third party code would be weird.

I plan to look into googlemock more in depth in the coming days, and I'll probably start writing a few common matchers (including replacing these macros) along with that effort. But since this code is already here, I might as well get it in first and do that as an incremental improvement.

[chandlerc]

In D33059#758161, @zturner wrote:

Moved the folder.

I don't particularly like the new name. ;]

Because we're not going to install anything, I don't think we need the 'include' directory component or to separate the headers from the source files.

If your concern is that #include "Helpers/Foo.h" isn't clear because Helpers is too generic, how about TestHelpers or UnittestHelpers? I'd still keep a single directory, and use more typical LLVM NamingConvention for it. =]

I really would like to put it in utils\unittest\googletest\include\gtest\Support, because then you could write

#include "gtest/gtest.h"
#include "gtest/Support/ErrorChecking.h"

Yeah this would be nice, but...

but I'm not sure if sticking our own directory inside of a directory of third party code would be weird.

I also think i would be weird. I'd like us to keep it separate.

[zturner]

In D33059#759727, @chandlerc wrote:

In D33059#758161, @zturner wrote:

but I'm not sure if sticking our own directory inside of a directory of third party code would be weird.

I also think i would be weird. I'd like us to keep it separate.

Bear with me here. Would it be more or less weird to have a directory of the same name but in a different location?

e.g.

utils
  googlemock
    include
      gmock
  googletest
    include
      gtest
  Support
    include
      gtest
        Support

This way you could still write #include "gtest/Support/ErrorChecking.h" but we wouldn't be stepping on third party code.

[chandlerc]

In D33059#759730, @zturner wrote:

In D33059#759727, @chandlerc wrote:

In D33059#758161, @zturner wrote:

but I'm not sure if sticking our own directory inside of a directory of third party code would be weird.

I also think i would be weird. I'd like us to keep it separate.

Bear with me here. Would it be more or less weird to have a directory of the same name but in a different location?

e.g.

utils
  googlemock
    include
      gmock
  googletest
    include
      gtest
  Support
    include
      gtest
        Support

This way you could still write #include "gtest/Support/ErrorChecking.h" but we wouldn't be stepping on third party code.

While I admire your cleverness here, I think a simpler solution would be better. ;]

[zturner]

Trying this again.

Note that this time I went all the way and added matchers instead of the hand rolled macros. that delegate to EXPECT_TRUE etc. Since gmock doesn't support matchers that modify their arguments, the solution here is to make a new EXPECT / ASSERT macro pair that consumes the Error, converting it into a format that can easily be copied around and passed through the mock infrastructure.

There's still some uses of hand rolled macros related to std::error_code in various tests, but I think it's too much for one patch. Maybe in a followup

[zturner]

A few improvements to error message printouts.

[zturner]

1. Moved the code from UnitTestHelpers to UnitTestHelpers/Support. If this is going to be a general purpose location for sharing code amongst unit tests, then it can't be specific to Support. For example, you might have need for specific matchers related to CodeGen or debug info that nothing outside of those unit tests would ever need to use, but that should still be usable by anything that depends on those. For example, you could write a matcher related to a SelectionDAG and it could be used in a general purpose CodeGen unit test or a target specific one. On the other hand, such a shared matcher doesn't belong next to a Support matcher because then anything that used Support would have to link against CodeGen, and obviously we don't want SupportTests and ADTTests linking CodeGen. We don't have this scenario yet, but I think we need to get the layout right the first time so it's ready to use immediately.

2. Got rid of StringRef.h. This was only there to have a formatter for StringRef, but due to the design of gmock, all printers really need to be declared in one master file. You don't want someone to get different output depending on whether they remember to include a specific header or not, and when you've got something like trying to print Expected<T>, the printer for Expected<T> needs to be able to find the printer for T or it will print a really ugly version of it, and the only way to remove this burden from the user is to make sure all custom printers are in one file.

[zturner]

ping, PTAL?

[zturner]

ping

[zturner]

[chandlerc]

FYI, I chatted with Zach in person to understand why the directory layout was as complicated as it was. I really wanted to simplify it. However, my initial attempts broke cross-project usage as Richard Smith pointed out, and this is *exactly* the kind of thing that we will really want to share across LLVM projects: Both LLD and potentially Clang will want access to things like the error matching utilities for their unittests.

With that constraint in mind, I talked for a long time with Richard about the tradeoffs here. Our suggested approach is to be less inventive: testing libraries are, fundamentally, *just libraries*. We probably don't want to install them and it should be clear that they are for testing (and so shouldn't be used elsewhere and can carry more dependencies than would be acceptable elsewhere). But they're still libraries. We suggest the file layout:

include/llvm/Testing/Support/Error.h
lib/Testing/Support/Error.cpp

And then you could use it from unittests/Support/FooTest.cpp in the obvious way:

#include "llvm/Testing/Support/Error.h"

This may be a bit controversial so it is worth making sure others are on board with this direction. The big thing that makes all of the other alternatives hard is ending up with a way for a Clang or LLD unittest to include a header for the llvm/Support or llvm/CodeGen testing utilities as well as their own clang/Basic or clang/CodeGen (see what I did there?) without confusion or in the latter case, a flat ambiguity.

An alternative if people are strongly opposed to just treating this like any other collection of LLVM libraries would have the file layout like:

utils/unittest/llvm-testing/Support/Error.cpp
utils/unittest/llvm-testing/Support/SupportHelpers.h

And then usage from unittests/Support/FooTest.cpp would look like:

#include "llvm-testing/Support/Error.h"

[MatzeB]

about the directories: 'meh'. I'm fine with whatever works.

• Why is a patch that claims to create a shared include directory actually changing so many unit tests?
• EXPECT_THAT_ERROR(x, Succeeded()) seems bad. SHouldn't this rather be EXPECT_THAT(x, succeeded()) to look more natural?

[zturner]

In D33059#778601, @MatzeB wrote:

about the directories: 'meh'. I'm fine with whatever works.

• Why is a patch that claims to create a shared include directory actually changing so many unit tests?

I felt like we needed a motivating example of why this effort is useful. The error macros were copy/pasted amongst many different files, so it was the perfect candidate.

• EXPECT_THAT_ERROR(x, Succeeded()) seems bad. SHouldn't this rather be EXPECT_THAT(x, succeeded()) to look more natural?

You're right, it is bad. But unfortunately there is not a good alternative. Error is a move only type, and gmock a) can't handle move only types, and b) can't exhibits undefined behavior if you change the state of an object you're matching inside of a matcher. Because of that, we have to convert the Error into something else by basically consuming its failure/success status and error messge and storing them in a different type, and then matching against that type. So we need the macro to convert the Error / Expected into the type we actually match against.

It's not ideal, but it seems like the best we can do for this one specific class.

[MatzeB]

In D33059#778617, @zturner wrote:

In D33059#778601, @MatzeB wrote:

about the directories: 'meh'. I'm fine with whatever works.

• Why is a patch that claims to create a shared include directory actually changing so many unit tests?

I felt like we needed a motivating example of why this effort is useful. The error macros were copy/pasted amongst many different files, so it was the perfect candidate.

So this doesn't really seem to be a "motivating" example that shows how gmock makes life simpler. But again I'm 'meh' here, I think we already decided to use gmock and I assume you guys have examples where it actually improves the experience.

[zturner]

In D33059#778618, @MatzeB wrote:

In D33059#778617, @zturner wrote:

In D33059#778601, @MatzeB wrote:

about the directories: 'meh'. I'm fine with whatever works.

• Why is a patch that claims to create a shared include directory actually changing so many unit tests?

I felt like we needed a motivating example of why this effort is useful. The error macros were copy/pasted amongst many different files, so it was the perfect candidate.

So this doesn't really seem to be a "motivating" example that shows how gmock makes life simpler. But again I'm 'meh' here, I think we already decided to use gmock and I assume you guys have examples where it actually improves the experience.

I'm not talking about gmock, I'm talking about a motivating example of why having a shared include directory is useful. That aside, I definitely think gmock improves the experience here. If you write EXPECT_THAT_ERROR(foo(), succeeded()) and it doesn't succeed, it will show you the error message that it failed with. Same thing with the Expected case.

[zturner]

To motivate the gmock specific portion, here are some examples of what happens when you get a test failure now using the new gmock matchers as implemented in this patch.

Error fails when you expect it to succeed:

E:\src\llvm-mono\llvm\unittests\DebugInfo\PDB\MappedBlockStreamTest.cpp(189): error: Value of: llvm::detail::TakeError(R.readFixedString(Str, 11))
Expected: succeeded
  Actual: failed  (Stream Error: The stream is too short to perform the requested operation.)

Expected fails when you expected it to succeed

E:\src\llvm-mono\llvm\unittests\DebugInfo\PDB\MSFBuilderTest.cpp(250): error: Value of: llvm::detail::TakeExpected(Msf.addStream(6144, Blocks))
Expected: succeeded
  Actual: failed  (MSF Error: Attempt to re-use an already allocated block)

Expected<T> operation succeeded but doesn't have the expected value.

E:\src\llvm-mono\llvm\unittests\DebugInfo\PDB\StringTableBuilderTest.cpp(51): error: Value of: llvm::detail::TakeExpected(Table.getStringForID(3))
Expected: succeeded with value "baz"
  Actual: succeeded with value "{ 'o' (111, 0x6F) }", but "{ 'o' (111, 0x6F) }" != "baz"

Expected<T> operation failed when you expected it to succeed with a certain value.

E:\src\llvm-mono\llvm\unittests\DebugInfo\PDB\StringTableBuilderTest.cpp(52): error: Value of: llvm::detail::TakeExpected(Table.getIDForString("abc"))
Expected: succeeded with value 1
  Actual: failed  (Native PDB Error: The entry does not exist.), operation failed

[labath]

In D33059#778617, @zturner wrote:

In D33059#778601, @MatzeB wrote:

about the directories: 'meh'. I'm fine with whatever works.

• Why is a patch that claims to create a shared include directory actually changing so many unit tests?

I felt like we needed a motivating example of why this effort is useful. The error macros were copy/pasted amongst many different files, so it was the perfect candidate.

• EXPECT_THAT_ERROR(x, Succeeded()) seems bad. SHouldn't this rather be EXPECT_THAT(x, succeeded()) to look more natural?

You're right, it is bad. But unfortunately there is not a good alternative. Error is a move only type, and gmock a) can't handle move only types, and b) can't exhibits undefined behavior if you change the state of an object you're matching inside of a matcher. Because of that, we have to convert the Error into something else by basically consuming its failure/success status and error messge and storing them in a different type, and then matching against that type. So we need the macro to convert the Error / Expected into the type we actually match against.

It's not ideal, but it seems like the best we can do for this one specific class.

I think it is possible to avoid the explosion of EXPECT/ASSERT_THAT_<FOO> macros (I can't think of any right now, but I'm sure something will crop up eventually, which will require specific handling). For example, we could just define a single expect macro, and hide all of the type-specific stuff in the helper function. Then overload resolution should take care of selecting the right behavior.

I'm thinking of something like:

#define EXPECT(Obj, Matcher) EXPECT_THAT(::llvm::detail::gmock_helper(Obj), Matcher)
#define ASSERT(Obj, Matcher) ASSERT_THAT(::llvm::detail::gmock_helper(Obj), Matcher)

template<typename T>
T gmock_helper(T Obj) { return Obj; }

template<typename T>
ExpectedHolder<T> gmock_helper(Expected<T> Obj) { ... }

This way, we could just write ASSERT(foo, bar) always (names are just a suggestion, but I would prefer something shorter than ASSERT_THAT_EXPECTED), and if a type needed special handling, we would just specialize gmock_helper. What do you think?

(Disclaimer: I haven't tried to actually implement this, but I don't see a reason why it wouldn't work)

[chandlerc]

In D33059#778716, @labath wrote:

I think it is possible to avoid the explosion of EXPECT/ASSERT_THAT_<FOO> macros (I can't think of any right now, but I'm sure something will crop up eventually, which will require specific handling).

There are a lot of things we can investigate to make this better. However, I don't think they belong in this patch. This patch is *mostly* about consolidating where things live to a common home. It does so. It updates some custom macro expectations to be slightly different custom macro expectations with specific benefits Zach outlined.

Because these were already custom macros, I consider this "no harm done". I wouldn't want to go farther than that in this patch though, I'd prefer to get this (or something like it) in place to prove the concept of building more robust libraries that make testing easy and effective. Once we have that, we can write a much more focused patch that *just* tries to improve these particular cases to not require custom macros.

I'm refraining from commenting on any particulars of the approach you suggest or alternatives for that future time / place / discussion.

[labath]

In D33059#778722, @chandlerc wrote:

In D33059#778716, @labath wrote:

I think it is possible to avoid the explosion of EXPECT/ASSERT_THAT_<FOO> macros (I can't think of any right now, but I'm sure something will crop up eventually, which will require specific handling).

There are a lot of things we can investigate to make this better. However, I don't think they belong in this patch. This patch is *mostly* about consolidating where things live to a common home. It does so. It updates some custom macro expectations to be slightly different custom macro expectations with specific benefits Zach outlined.

Because these were already custom macros, I consider this "no harm done". I wouldn't want to go farther than that in this patch though, I'd prefer to get this (or something like it) in place to prove the concept of building more robust libraries that make testing easy and effective. Once we have that, we can write a much more focused patch that *just* tries to improve these particular cases to not require custom macros.

I'm refraining from commenting on any particulars of the approach you suggest or alternatives for that future time / place / discussion.

Fair enough. I'll wait until this patch lands to propose that.

[zturner]

Updated with new directory layout suggestions.

[chandlerc]

LGTM. Some comments below about the name of the library and getting the linking and other stuff set up correctly, but I'm happy for you to sort that out and land (and fix bots as necessary) w/o going through more rounds of review. =D

One thing I would suggest is mentioning the fact that the particular interface being used for the EXPECT_THAT_ERROR stuff is likely to have further progress to try and improve it, but that this at least consolidates things and provides a clear place for that development to take place. Hopefully that'll help other folks on the commit list understand the context that came up in this review.

Lastly, you should add some warning text somewhere in this code here (maybe a readme near the headers? maybe just in the headers?) that this is intended for use for testing *only*, and shouldn't be depended on by any non-test code. And you should probably add some discussion of this libarry (and the above warning) to the programmer guide for LLVM. But I'm happy for that to be done in subsequent commits where convenient.

Thansk for working on the infrastructure here!

llvm/lib/Testing/Support/CMakeLists.txt

1 ↗

(On Diff #102340)

I would call this 'LLVMTestingSupport' to match the directory name I guess?

8–9 ↗

(On Diff #102340)

Do you need to link gtest and gmock as well? I'm guessing without that a shared build will fail...

llvm/cmake/modules/AddLLVM.cmake

 # Generic support for adding a unittest.
 function(add_unittest test_suite test_name)
   if( NOT LLVM_BUILD_TESTS )
     set(EXCLUDE_FROM_ALL ON)
   endif()
 
   include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include)
   include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googlemock/include)
+  include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/Helpers/include)
   if (NOT LLVM_ENABLE_THREADS)
     list(APPEND LLVM_COMPILE_DEFINITIONS GTEST_HAS_PTHREAD=0)
   endif ()
 
   if (SUPPORTS_VARIADIC_MACROS_FLAG)
     list(APPEND LLVM_COMPILE_FLAGS "-Wno-variadic-macros")
   endif ()
   # Some parts of gtest rely on this GNU extension, don't warn on it.

llvm/unittests/DebugInfo/CodeView/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoCodeView
+  UnitTestHelpers
   )
 
 set(DebugInfoCodeViewSources
   RandomAccessVisitorTest.cpp
   TypeIndexDiscoveryTest.cpp
   )
 
 add_llvm_unittest(DebugInfoCodeViewTests
   ${DebugInfoCodeViewSources}
   )

llvm/unittests/DebugInfo/CodeView/ErrorChecking.h

-//===- ErrorChecking.h - Helpers for verifying llvm::Errors -----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_UNITTESTS_DEBUGINFO_CODEVIEW_ERRORCHECKING_H
-#define LLVM_UNITTESTS_DEBUGINFO_CODEVIEW_ERRORCHECKING_H
-
-#define EXPECT_NO_ERROR(Err)                                                   \
-  {                                                                            \
-    auto E = Err;                                                              \
-    EXPECT_FALSE(static_cast<bool>(E));                                        \
-    if (E)                                                                     \
-      consumeError(std::move(E));                                              \
-  }
-
-#define EXPECT_ERROR(Err)                                                      \
-  {                                                                            \
-    auto E = Err;                                                              \
-    EXPECT_TRUE(static_cast<bool>(E));                                         \
-    if (E)                                                                     \
-      consumeError(std::move(E));                                              \
-  }
-
-#define ASSERT_EXPECTED(Exp)                                                   \
-  {                                                                            \
-    auto E = Exp.takeError();                                                  \
-    bool Success = static_cast<bool>(E);                                       \
-    if (!Success)                                                              \
-      consumeError(std::move(E));                                              \
-    ASSERT_FALSE(Success);                                                     \
-  }
-
-#define EXPECT_EXPECTED(Exp)                                                   \
-  {                                                                            \
-    auto E = Exp.takeError();                                                  \
-    EXPECT_FALSE(static_cast<bool>(E));                                        \
-    if (E) {                                                                   \
-      consumeError(std::move(E));                                              \
-      return;                                                                  \
-    }                                                                          \
-  }
-
-#define EXPECT_EXPECTED_EQ(Val, Exp)                                           \
-  {                                                                            \
-    auto Result = Exp;                                                         \
-    auto E = Result.takeError();                                               \
-    EXPECT_FALSE(static_cast<bool>(E));                                        \
-    if (E) {                                                                   \
-      consumeError(std::move(E));                                              \
-      return;                                                                  \
-    }                                                                          \
-    EXPECT_EQ(Val, *Result);                                                   \
-  }
-
-#define EXPECT_UNEXPECTED(Exp)                                                 \
-  {                                                                            \
-    auto E = Exp.takeError();                                                  \
-    EXPECT_TRUE(static_cast<bool>(E));                                         \
-    if (E) {                                                                   \
-      consumeError(std::move(E));                                              \
-      return;                                                                  \
-    }                                                                          \
-  }
-
-#endif

llvm/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp

 //===- llvm/unittest/DebugInfo/CodeView/RandomAccessVisitorTest.cpp -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ErrorChecking.h"
-
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
 #include "llvm/DebugInfo/CodeView/TypeSerializer.h"
 #include "llvm/DebugInfo/CodeView/TypeServerHandler.h"
 #include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/BinaryItemStream.h"
 #include "llvm/Support/Error.h"
 
+#include "UnittestHelpers/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 namespace llvm {
 namespace codeview {
LazyRandomTypeCollection Types(GlobalState->TypeArray,
                                  GlobalState->TypeVector.size(),
                                  TestState->Offsets);
 
   std::vector<uint32_t> IndicesToVisit = {5, 5, 5};
 
   for (uint32_t I : IndicesToVisit) {
     TypeIndex TI = TypeIndex::fromArrayIndex(I);
     CVType T = Types.getType(TI);
-    EXPECT_NO_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks));
+    EXPECT_THAT_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks),
+                      Succeeded());
   }
 
   // [0,8) should be present
   EXPECT_EQ(8u, Types.size());
   for (uint32_t I = 0; I < 8; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // 5, 5, 5
TEST_F(RandomAccessVisitorTest, DescendingWithinChunk) {
   std::vector<uint32_t> IndicesToVisit = {7, 4, 2};
 
   LazyRandomTypeCollection Types(GlobalState->TypeArray,
                                  GlobalState->TypeVector.size(),
                                  TestState->Offsets);
   for (uint32_t I : IndicesToVisit) {
     TypeIndex TI = TypeIndex::fromArrayIndex(I);
     CVType T = Types.getType(TI);
-    EXPECT_NO_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks));
+    EXPECT_THAT_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks),
+                      Succeeded());
   }
 
   // [0, 7]
   EXPECT_EQ(8u, Types.size());
   for (uint32_t I = 0; I < 8; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // 2, 4, 7
TEST_F(RandomAccessVisitorTest, AscendingWithinChunk) {
   std::vector<uint32_t> IndicesToVisit = {2, 4, 7};
 
   LazyRandomTypeCollection Types(GlobalState->TypeArray,
                                  GlobalState->TypeVector.size(),
                                  TestState->Offsets);
   for (uint32_t I : IndicesToVisit) {
     TypeIndex TI = TypeIndex::fromArrayIndex(I);
     CVType T = Types.getType(TI);
-    EXPECT_NO_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks));
+    EXPECT_THAT_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks),
+                      Succeeded());
   }
 
   // [0, 7]
   EXPECT_EQ(8u, Types.size());
   for (uint32_t I = 0; I < 8; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // 2, 4, 7
TEST_F(RandomAccessVisitorTest, StopPrematurelyInChunk) {
 
   LazyRandomTypeCollection Types(GlobalState->TypeArray,
                                  GlobalState->TypeVector.size(),
                                  TestState->Offsets);
 
   for (uint32_t I : IndicesToVisit) {
     TypeIndex TI = TypeIndex::fromArrayIndex(I);
     CVType T = Types.getType(TI);
-    EXPECT_NO_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks));
+    EXPECT_THAT_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks),
+                      Succeeded());
   }
 
   // [0, 8) should be visited.
   EXPECT_EQ(8u, Types.size());
   for (uint32_t I = 0; I < 8; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // [0, 2]
TEST_F(RandomAccessVisitorTest, InnerChunk) {
 
   LazyRandomTypeCollection Types(GlobalState->TypeArray,
                                  GlobalState->TypeVector.size(),
                                  TestState->Offsets);
 
   for (uint32_t I : IndicesToVisit) {
     TypeIndex TI = TypeIndex::fromArrayIndex(I);
     CVType T = Types.getType(TI);
-    EXPECT_NO_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks));
+    EXPECT_THAT_ERROR(codeview::visitTypeRecord(T, TI, TestState->Callbacks),
+                      Succeeded());
   }
 
   // [4, 9)
   EXPECT_EQ(5u, Types.size());
   for (uint32_t I = 4; I < 9; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // 5, 7
   EXPECT_EQ(2u, TestState->Callbacks.count());
   for (auto &I : enumerate(IndicesToVisit))
     EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
 }

llvm/unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp

 //===- llvm/unittest/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp --------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
 
-#include "ErrorChecking.h"
 #include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
 #include "llvm/Support/Allocator.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
writeFieldList(BaseClass, Enumerator, DataMember, OverloadedMethod,
                  Continuation);
 
   checkTypeReferences(
       0, BaseClass.Type, DataMember.Type, OverloadedMethod.MethodList,
       OneMethod.T1, OneMethod.T2, OneMethod.T3, OneMethod.T4, NestedType.Type,
       StaticDataMember.Type, VirtualBaseClass.BaseType,
       VirtualBaseClass.VBPtrType, VFPtr.Type, Continuation.ContinuationIndex);
 }
 No newline at end of file

llvm/unittests/DebugInfo/PDB/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoCodeView
   DebugInfoMSF
   DebugInfoPDB
+  UnitTestHelpers
   )
 
 set(DebugInfoPDBSources
   HashTableTest.cpp
   MappedBlockStreamTest.cpp
   StringTableBuilderTest.cpp
   MSFBuilderTest.cpp
   PDBApiTest.cpp
   TypeServerHandlerTest.cpp
   )
 
 add_llvm_unittest(DebugInfoPDBTests
   ${DebugInfoPDBSources}
   )

llvm/unittests/DebugInfo/PDB/ErrorChecking.h

-//===- ErrorChecking.h - Helpers for verifying llvm::Errors -----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_UNITTESTS_DEBUGINFO_PDB_ERRORCHECKING_H
-#define LLVM_UNITTESTS_DEBUGINFO_PDB_ERRORCHECKING_H
-
-#define EXPECT_NO_ERROR(Err)                                                   \
-  {                                                                            \
-    auto E = Err;                                                              \
-    EXPECT_FALSE(static_cast<bool>(E));                                        \
-    if (E)                                                                     \
-      consumeError(std::move(E));                                              \
-  }
-
-#define EXPECT_ERROR(Err)                                                      \
-  {                                                                            \
-    auto E = Err;                                                              \
-    EXPECT_TRUE(static_cast<bool>(E));                                         \
-    if (E)                                                                     \
-      consumeError(std::move(E));                                              \
-  }
-
-#define EXPECT_EXPECTED(Exp)                                                   \
-  {                                                                            \
-    auto E = Exp.takeError();                                                  \
-    EXPECT_FALSE(static_cast<bool>(E));                                        \
-    if (E) {                                                                   \
-      consumeError(std::move(E));                                              \
-      return;                                                                  \
-    }                                                                          \
-  }
-
-#define EXPECT_EXPECTED_EQ(Val, Exp)                                           \
-  {                                                                            \
-    auto Result = Exp;                                                         \
-    auto E = Result.takeError();                                               \
-    EXPECT_FALSE(static_cast<bool>(E));                                        \
-    if (E) {                                                                   \
-      consumeError(std::move(E));                                              \
-      return;                                                                  \
-    }                                                                          \
-    EXPECT_EQ(Val, *Result);                                                   \
-  }
-
-#define EXPECT_UNEXPECTED(Exp)                                                 \
-  {                                                                            \
-    auto E = Exp.takeError();                                                  \
-    EXPECT_TRUE(static_cast<bool>(E));                                         \
-    if (E) {                                                                   \
-      consumeError(std::move(E));                                              \
-      return;                                                                  \
-    }                                                                          \
-  }
-
-#endif

llvm/unittests/DebugInfo/PDB/HashTableTest.cpp

 //===- llvm/unittest/DebugInfo/PDB/HashTableTest.cpp ----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ErrorChecking.h"
-#include "gtest/gtest.h"
-
 #include "llvm/DebugInfo/PDB/Native/HashTable.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 
+#include "UnitTestHelpers/Error.h"
+#include "gtest/gtest.h"
+
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::pdb;
 using namespace llvm::support;
 
 namespace {
 class HashTableInternals : public HashTable {
TEST(HashTableTest, Serialization) {
   uint32_t Cap = Table.capacity();
   for (uint32_t I = 0; I < Cap; ++I) {
     Table.set(Cap + I * 2 + 1, I * 2 + 3);
   }
 
   std::vector<uint8_t> Buffer(Table.calculateSerializedLength());
   MutableBinaryByteStream Stream(Buffer, little);
   BinaryStreamWriter Writer(Stream);
-  EXPECT_NO_ERROR(Table.commit(Writer));
+  EXPECT_THAT_ERROR(Table.commit(Writer), Succeeded());
   // We should have written precisely the number of bytes we calculated earlier.
   EXPECT_EQ(Buffer.size(), Writer.getOffset());
 
   HashTableInternals Table2;
   BinaryStreamReader Reader(Stream);
-  EXPECT_NO_ERROR(Table2.load(Reader));
+  EXPECT_THAT_ERROR(Table2.load(Reader), Succeeded());
   // We should have read precisely the number of bytes we calculated earlier.
   EXPECT_EQ(Buffer.size(), Reader.getOffset());
 
   EXPECT_EQ(Table.size(), Table2.size());
   EXPECT_EQ(Table.capacity(), Table2.capacity());
   EXPECT_EQ(Table.Buckets, Table2.Buckets);
   EXPECT_EQ(Table.Present, Table2.Present);
   EXPECT_EQ(Table.Deleted, Table2.Deleted);
 }

llvm/unittests/DebugInfo/PDB/MSFBuilderTest.cpp

 //===- MSFBuilderTest.cpp  Tests manipulation of MSF stream metadata ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ErrorChecking.h"
-
 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
 #include "llvm/DebugInfo/MSF/MSFCommon.h"
 
+#include "UnitTestHelpers/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::msf;
 
 namespace {
 class MSFBuilderTest : public testing::Test {
 protected:

 };
 }
 
 TEST_F(MSFBuilderTest, ValidateSuperBlockAccept) {
   // Test that a known good super block passes validation.
   SuperBlock SB;
   initializeSuperBlock(SB);
 
-  EXPECT_NO_ERROR(msf::validateSuperBlock(SB));
+  EXPECT_THAT_ERROR(msf::validateSuperBlock(SB), Succeeded());
 }
 
 TEST_F(MSFBuilderTest, ValidateSuperBlockReject) {
   // Test that various known problems cause a super block to be rejected.
   SuperBlock SB;
   initializeSimpleSuperBlock(SB);
 
   // Mismatched magic
   SB.MagicBytes[0] = 8;
-  EXPECT_ERROR(msf::validateSuperBlock(SB));
+  EXPECT_THAT_ERROR(msf::validateSuperBlock(SB), Failed());
   initializeSimpleSuperBlock(SB);
 
   // Block 0 is reserved for super block, can't be occupied by the block map
   SB.BlockMapAddr = 0;
-  EXPECT_ERROR(msf::validateSuperBlock(SB));
+  EXPECT_THAT_ERROR(msf::validateSuperBlock(SB), Failed());
   initializeSimpleSuperBlock(SB);
 
   // Block sizes have to be powers of 2.
   SB.BlockSize = 3120;
-  EXPECT_ERROR(msf::validateSuperBlock(SB));
+  EXPECT_THAT_ERROR(msf::validateSuperBlock(SB), Failed());
   initializeSimpleSuperBlock(SB);
 
   // The directory itself has a maximum size.
   SB.NumDirectoryBytes = SB.BlockSize * SB.BlockSize / 4;
-  EXPECT_NO_ERROR(msf::validateSuperBlock(SB));
+  EXPECT_THAT_ERROR(msf::validateSuperBlock(SB), Succeeded());
   SB.NumDirectoryBytes = SB.NumDirectoryBytes + 4;
-  EXPECT_ERROR(msf::validateSuperBlock(SB));
+  EXPECT_THAT_ERROR(msf::validateSuperBlock(SB), Failed());
 }
 
 TEST_F(MSFBuilderTest, TestUsedBlocksMarkedAsUsed) {
   // Test that when assigning a stream to a known list of blocks, the blocks
   // are correctly marked as used after adding, but no other incorrect blocks
   // are accidentally marked as used.
 
   std::vector<uint32_t> Blocks = {4, 5, 6, 7, 8, 9, 10, 11, 12};
   // Allocate some extra blocks at the end so we can verify that they're free
   // after the initialization.
   uint32_t NumBlocks = msf::getMinimumBlockCount() + Blocks.size() + 10;
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096, NumBlocks);
-  EXPECT_EXPECTED(ExpectedMsf);
+  ASSERT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
-  EXPECT_EXPECTED(Msf.addStream(Blocks.size() * 4096, Blocks));
+  EXPECT_THAT_EXPECTED(Msf.addStream(Blocks.size() * 4096, Blocks),
+                       Succeeded());
 
   for (auto B : Blocks) {
     EXPECT_FALSE(Msf.isBlockFree(B));
   }
 
   uint32_t FreeBlockStart = Blocks.back() + 1;
   for (uint32_t I = FreeBlockStart; I < NumBlocks; ++I) {
     EXPECT_TRUE(Msf.isBlockFree(I));
   }
 }
 
 TEST_F(MSFBuilderTest, TestAddStreamNoDirectoryBlockIncrease) {
   // Test that adding a new stream correctly updates the directory.  This only
   // tests the case where the directory *DOES NOT* grow large enough that it
   // crosses a Block boundary.
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
   auto ExpectedL1 = Msf.build();
-  EXPECT_EXPECTED(ExpectedL1);
+  EXPECT_THAT_EXPECTED(ExpectedL1, Succeeded());
   MSFLayout &L1 = *ExpectedL1;
 
   auto OldDirBlocks = L1.DirectoryBlocks;
   EXPECT_EQ(1U, OldDirBlocks.size());
 
   auto ExpectedMsf2 = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf2);
+  EXPECT_THAT_EXPECTED(ExpectedMsf2, Succeeded());
   auto &Msf2 = *ExpectedMsf2;
 
-  EXPECT_EXPECTED(Msf2.addStream(4000));
+  EXPECT_THAT_EXPECTED(Msf2.addStream(4000), Succeeded());
   EXPECT_EQ(1U, Msf2.getNumStreams());
   EXPECT_EQ(4000U, Msf2.getStreamSize(0));
   auto Blocks = Msf2.getStreamBlocks(0);
   EXPECT_EQ(1U, Blocks.size());
 
   auto ExpectedL2 = Msf2.build();
-  EXPECT_EXPECTED(ExpectedL2);
+  EXPECT_THAT_EXPECTED(ExpectedL2, Succeeded());
   MSFLayout &L2 = *ExpectedL2;
   auto NewDirBlocks = L2.DirectoryBlocks;
   EXPECT_EQ(1U, NewDirBlocks.size());
 }
 
 TEST_F(MSFBuilderTest, TestAddStreamWithDirectoryBlockIncrease) {
   // Test that adding a new stream correctly updates the directory.  This only
   // tests the case where the directory *DOES* grow large enough that it
   // crosses a Block boundary.  This is because the newly added stream occupies
   // so many Blocks that need to be indexed in the directory that the directory
   // crosses a Block boundary.
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
-  EXPECT_EXPECTED(Msf.addStream(4096 * 4096 / sizeof(uint32_t)));
+  EXPECT_THAT_EXPECTED(Msf.addStream(4096 * 4096 / sizeof(uint32_t)),
+                       Succeeded());
 
   auto ExpectedL1 = Msf.build();
-  EXPECT_EXPECTED(ExpectedL1);
+  EXPECT_THAT_EXPECTED(ExpectedL1, Succeeded());
   MSFLayout &L1 = *ExpectedL1;
   auto DirBlocks = L1.DirectoryBlocks;
   EXPECT_EQ(2U, DirBlocks.size());
 }
 
 TEST_F(MSFBuilderTest, TestGrowStreamNoBlockIncrease) {
   // Test growing an existing stream by a value that does not affect the number
   // of blocks it occupies.
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
-  EXPECT_EXPECTED(Msf.addStream(1024));
+  EXPECT_THAT_EXPECTED(Msf.addStream(1024), Succeeded());
   EXPECT_EQ(1024U, Msf.getStreamSize(0));
   auto OldStreamBlocks = Msf.getStreamBlocks(0);
   EXPECT_EQ(1U, OldStreamBlocks.size());
 
-  EXPECT_NO_ERROR(Msf.setStreamSize(0, 2048));
+  EXPECT_THAT_ERROR(Msf.setStreamSize(0, 2048), Succeeded());
   EXPECT_EQ(2048U, Msf.getStreamSize(0));
   auto NewStreamBlocks = Msf.getStreamBlocks(0);
   EXPECT_EQ(1U, NewStreamBlocks.size());
 
   EXPECT_EQ(OldStreamBlocks, NewStreamBlocks);
 }
 
 TEST_F(MSFBuilderTest, TestGrowStreamWithBlockIncrease) {
   // Test that growing an existing stream to a value large enough that it causes
   // the need to allocate new Blocks to the stream correctly updates the
   // stream's
   // block list.
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
-  EXPECT_EXPECTED(Msf.addStream(2048));
+  EXPECT_THAT_EXPECTED(Msf.addStream(2048), Succeeded());
   EXPECT_EQ(2048U, Msf.getStreamSize(0));
   std::vector<uint32_t> OldStreamBlocks = Msf.getStreamBlocks(0);
   EXPECT_EQ(1U, OldStreamBlocks.size());
 
-  EXPECT_NO_ERROR(Msf.setStreamSize(0, 6144));
+  EXPECT_THAT_ERROR(Msf.setStreamSize(0, 6144), Succeeded());
   EXPECT_EQ(6144U, Msf.getStreamSize(0));
   std::vector<uint32_t> NewStreamBlocks = Msf.getStreamBlocks(0);
   EXPECT_EQ(2U, NewStreamBlocks.size());
 
   EXPECT_EQ(OldStreamBlocks[0], NewStreamBlocks[0]);
   EXPECT_NE(NewStreamBlocks[0], NewStreamBlocks[1]);
 }
 
 TEST_F(MSFBuilderTest, TestShrinkStreamNoBlockDecrease) {
   // Test that shrinking an existing stream by a value that does not affect the
   // number of Blocks it occupies makes no changes to stream's block list.
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
-  EXPECT_EXPECTED(Msf.addStream(2048));
+  EXPECT_THAT_EXPECTED(Msf.addStream(2048), Succeeded());
   EXPECT_EQ(2048U, Msf.getStreamSize(0));
   std::vector<uint32_t> OldStreamBlocks = Msf.getStreamBlocks(0);
   EXPECT_EQ(1U, OldStreamBlocks.size());
 
-  EXPECT_NO_ERROR(Msf.setStreamSize(0, 1024));
+  EXPECT_THAT_ERROR(Msf.setStreamSize(0, 1024), Succeeded());
   EXPECT_EQ(1024U, Msf.getStreamSize(0));
   std::vector<uint32_t> NewStreamBlocks = Msf.getStreamBlocks(0);
   EXPECT_EQ(1U, NewStreamBlocks.size());
 
   EXPECT_EQ(OldStreamBlocks, NewStreamBlocks);
 }
 
 TEST_F(MSFBuilderTest, TestShrinkStreamWithBlockDecrease) {
   // Test that shrinking an existing stream to a value large enough that it
   // causes the need to deallocate new Blocks to the stream correctly updates
   // the stream's block list.
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
-  EXPECT_EXPECTED(Msf.addStream(6144));
+  EXPECT_THAT_EXPECTED(Msf.addStream(6144), Succeeded());
   EXPECT_EQ(6144U, Msf.getStreamSize(0));
   std::vector<uint32_t> OldStreamBlocks = Msf.getStreamBlocks(0);
   EXPECT_EQ(2U, OldStreamBlocks.size());
 
-  EXPECT_NO_ERROR(Msf.setStreamSize(0, 2048));
+  EXPECT_THAT_ERROR(Msf.setStreamSize(0, 2048), Succeeded());
   EXPECT_EQ(2048U, Msf.getStreamSize(0));
   std::vector<uint32_t> NewStreamBlocks = Msf.getStreamBlocks(0);
   EXPECT_EQ(1U, NewStreamBlocks.size());
 
   EXPECT_EQ(OldStreamBlocks[0], NewStreamBlocks[0]);
 }
 
 TEST_F(MSFBuilderTest, TestRejectReusedStreamBlock) {
   // Test that attempting to add a stream and assigning a block that is already
   // in use by another stream fails.
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
-  EXPECT_EXPECTED(Msf.addStream(6144));
+  EXPECT_THAT_EXPECTED(Msf.addStream(6144), Succeeded());
 
   std::vector<uint32_t> Blocks = {2, 3};
-  EXPECT_UNEXPECTED(Msf.addStream(6144, Blocks));
+  EXPECT_THAT_EXPECTED(Msf.addStream(6144, Blocks), Failed());
 }
 
 TEST_F(MSFBuilderTest, TestBlockCountsWhenAddingStreams) {
   // Test that when adding multiple streams, the number of used and free Blocks
   // allocated to the MSF file are as expected.
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
   // one for the super block, one for the directory block map
   uint32_t NumUsedBlocks = Msf.getNumUsedBlocks();
   EXPECT_EQ(msf::getMinimumBlockCount(), NumUsedBlocks);
   EXPECT_EQ(0U, Msf.getNumFreeBlocks());
 
   const uint32_t StreamSizes[] = {4000, 6193, 189723};
   for (int I = 0; I < 3; ++I) {
-    EXPECT_EXPECTED(Msf.addStream(StreamSizes[I]));
+    EXPECT_THAT_EXPECTED(Msf.addStream(StreamSizes[I]), Succeeded());
     NumUsedBlocks += bytesToBlocks(StreamSizes[I], 4096);
     EXPECT_EQ(NumUsedBlocks, Msf.getNumUsedBlocks());
     EXPECT_EQ(0U, Msf.getNumFreeBlocks());
   }
 }
 
 TEST_F(MSFBuilderTest, BuildMsfLayout) {
   // Test that we can generate an MSFLayout structure from a valid layout
   // specification.
   auto ExpectedMsf = MSFBuilder::create(Allocator, 4096);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
   const uint32_t StreamSizes[] = {4000, 6193, 189723};
   uint32_t ExpectedNumBlocks = msf::getMinimumBlockCount();
   for (int I = 0; I < 3; ++I) {
-    EXPECT_EXPECTED(Msf.addStream(StreamSizes[I]));
+    EXPECT_THAT_EXPECTED(Msf.addStream(StreamSizes[I]), Succeeded());
     ExpectedNumBlocks += bytesToBlocks(StreamSizes[I], 4096);
   }
   ++ExpectedNumBlocks; // The directory itself should use 1 block
 
   auto ExpectedLayout = Msf.build();
-  EXPECT_EXPECTED(ExpectedLayout);
+  EXPECT_THAT_EXPECTED(ExpectedLayout, Succeeded());
   MSFLayout &L = *ExpectedLayout;
   EXPECT_EQ(4096U, L.SB->BlockSize);
   EXPECT_EQ(ExpectedNumBlocks, L.SB->NumBlocks);
 
   EXPECT_EQ(1U, L.DirectoryBlocks.size());
 
   EXPECT_EQ(3U, L.StreamMap.size());
   EXPECT_EQ(3U, L.StreamSizes.size());
   for (int I = 0; I < 3; ++I) {
     EXPECT_EQ(StreamSizes[I], L.StreamSizes[I]);
     uint32_t ExpectedNumBlocks = bytesToBlocks(StreamSizes[I], 4096);
     EXPECT_EQ(ExpectedNumBlocks, L.StreamMap[I].size());
   }
 }
 
 TEST_F(MSFBuilderTest, UseDirectoryBlockHint) {
   Expected<MSFBuilder> ExpectedMsf = MSFBuilder::create(
       Allocator, 4096, msf::getMinimumBlockCount() + 1, false);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
   uint32_t B = msf::getFirstUnreservedBlock();
-  EXPECT_NO_ERROR(Msf.setDirectoryBlocksHint({B + 1}));
-  EXPECT_EXPECTED(Msf.addStream(2048, {B + 2}));
+  EXPECT_THAT_ERROR(Msf.setDirectoryBlocksHint({B + 1}), Succeeded());
+  EXPECT_THAT_EXPECTED(Msf.addStream(2048, {B + 2}), Succeeded());
 
   auto ExpectedLayout = Msf.build();
-  EXPECT_EXPECTED(ExpectedLayout);
+  EXPECT_THAT_EXPECTED(ExpectedLayout, Succeeded());
   MSFLayout &L = *ExpectedLayout;
   EXPECT_EQ(msf::getMinimumBlockCount() + 2, L.SB->NumBlocks);
   EXPECT_EQ(1U, L.DirectoryBlocks.size());
   EXPECT_EQ(1U, L.StreamMap[0].size());
 
   EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
   EXPECT_EQ(B + 2, L.StreamMap[0].front());
 }
 
 TEST_F(MSFBuilderTest, DirectoryBlockHintInsufficient) {
   Expected<MSFBuilder> ExpectedMsf =
       MSFBuilder::create(Allocator, 4096, msf::getMinimumBlockCount() + 2);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
   uint32_t B = msf::getFirstUnreservedBlock();
-  EXPECT_NO_ERROR(Msf.setDirectoryBlocksHint({B + 1}));
+  EXPECT_THAT_ERROR(Msf.setDirectoryBlocksHint({B + 1}), Succeeded());
 
   uint32_t Size = 4096 * 4096 / 4;
-  EXPECT_EXPECTED(Msf.addStream(Size));
+  EXPECT_THAT_EXPECTED(Msf.addStream(Size), Succeeded());
 
   auto ExpectedLayout = Msf.build();
-  EXPECT_EXPECTED(ExpectedLayout);
+  EXPECT_THAT_EXPECTED(ExpectedLayout, Succeeded());
   MSFLayout &L = *ExpectedLayout;
   EXPECT_EQ(2U, L.DirectoryBlocks.size());
   EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
 }
 
 TEST_F(MSFBuilderTest, DirectoryBlockHintOverestimated) {
   Expected<MSFBuilder> ExpectedMsf =
       MSFBuilder::create(Allocator, 4096, msf::getMinimumBlockCount() + 2);
-  EXPECT_EXPECTED(ExpectedMsf);
+  EXPECT_THAT_EXPECTED(ExpectedMsf, Succeeded());
   auto &Msf = *ExpectedMsf;
 
   uint32_t B = msf::getFirstUnreservedBlock();
-  EXPECT_NO_ERROR(Msf.setDirectoryBlocksHint({B + 1, B + 2}));
+  EXPECT_THAT_ERROR(Msf.setDirectoryBlocksHint({B + 1, B + 2}), Succeeded());
 
-  EXPECT_EXPECTED(Msf.addStream(2048));
+  EXPECT_THAT_EXPECTED(Msf.addStream(2048), Succeeded());
 
   auto ExpectedLayout = Msf.build();
-  EXPECT_EXPECTED(ExpectedLayout);
+  EXPECT_THAT_EXPECTED(ExpectedLayout, Succeeded());
   MSFLayout &L = *ExpectedLayout;
   EXPECT_EQ(1U, L.DirectoryBlocks.size());
   EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
 }

llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp

 //===- llvm/unittest/DebugInfo/PDB/MappedBlockStreamTest.cpp --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ErrorChecking.h"
-
 #include "llvm/DebugInfo/MSF/IMSFFile.h"
 #include "llvm/DebugInfo/MSF/MSFError.h"
 #include "llvm/DebugInfo/MSF/MSFStreamLayout.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 #include "gtest/gtest.h"
 
+#include "UnitTestHelpers/Error.h"
+
 #include <unordered_map>
 
 using namespace llvm;
 using namespace llvm::msf;
 using namespace llvm::support;
 
 namespace {
 

 // and does not allocate.
 TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
 
   BinaryStreamReader R(*S);
   BinaryStreamRef SR;
-  EXPECT_NO_ERROR(R.readStreamRef(SR, 0U));
+  EXPECT_THAT_ERROR(R.readStreamRef(SR, 0U), Succeeded());
   ArrayRef<uint8_t> Buffer;
-  EXPECT_ERROR(SR.readBytes(0U, 1U, Buffer));
-  EXPECT_NO_ERROR(R.readStreamRef(SR, 1U));
-  EXPECT_ERROR(SR.readBytes(1U, 1U, Buffer));
+  EXPECT_THAT_ERROR(SR.readBytes(0U, 1U, Buffer), Failed());
+  EXPECT_THAT_ERROR(R.readStreamRef(SR, 1U), Succeeded());
+  EXPECT_THAT_ERROR(SR.readBytes(1U, 1U, Buffer), Failed());
 }
 
 // Tests that a read which outputs into a full destination buffer works and
 // does not fail due to the length of the output buffer.
 TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
 
   BinaryStreamReader R(*S);
   StringRef Str = "ZYXWVUTSRQPONMLKJIHGFEDCBA";
-  EXPECT_NO_ERROR(R.readFixedString(Str, 1));
+  EXPECT_THAT_ERROR(R.readFixedString(Str, 1), Succeeded());
   EXPECT_EQ(Str, StringRef("A"));
   EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
 }
 
 // Tests that a read which crosses a block boundary, but where the subsequent
 // blocks are still contiguous in memory to the previous block works and does
 // not allocate memory.
 TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
   BinaryStreamReader R(*S);
   StringRef Str;
-  EXPECT_NO_ERROR(R.readFixedString(Str, 2));
+  EXPECT_THAT_ERROR(R.readFixedString(Str, 2), Succeeded());
   EXPECT_EQ(Str, StringRef("AB"));
   EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
 
   R.setOffset(6);
-  EXPECT_NO_ERROR(R.readFixedString(Str, 4));
+  EXPECT_THAT_ERROR(R.readFixedString(Str, 4), Succeeded());
   EXPECT_EQ(Str, StringRef("GHIJ"));
   EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
 }
 
 // Tests that a read which crosses a block boundary and cannot be referenced
 // contiguously works and allocates only the precise amount of bytes
 // requested.
 TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
   BinaryStreamReader R(*S);
   StringRef Str;
-  EXPECT_NO_ERROR(R.readFixedString(Str, 10));
+  EXPECT_THAT_ERROR(R.readFixedString(Str, 10), Succeeded());
   EXPECT_EQ(Str, StringRef("ABCDEFGHIJ"));
   EXPECT_EQ(10U, F.Allocator.getBytesAllocated());
 }
 
 // Test that an out of bounds read which doesn't cross a block boundary
 // fails and allocates no memory.
 TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
   BinaryStreamReader R(*S);
   StringRef Str;
 
   R.setOffset(10);
-  EXPECT_ERROR(R.readFixedString(Str, 1));
+  EXPECT_THAT_ERROR(R.readFixedString(Str, 1), Failed());
   EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
 }
 
 // Test that an out of bounds read which crosses a contiguous block boundary
 // fails and allocates no memory.
 TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
   BinaryStreamReader R(*S);
   StringRef Str;
 
   R.setOffset(6);
-  EXPECT_ERROR(R.readFixedString(Str, 5));
+  EXPECT_THAT_ERROR(R.readFixedString(Str, 5), Failed());
   EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
 }
 
 // Test that an out of bounds read which crosses a discontiguous block
 // boundary fails and allocates no memory.
 TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
   BinaryStreamReader R(*S);
   StringRef Str;
 
-  EXPECT_ERROR(R.readFixedString(Str, 11));
+  EXPECT_THAT_ERROR(R.readFixedString(Str, 11), Failed());
   EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
 }
 
 // Tests that a read which is entirely contained within a single block but
 // beyond the end of a StreamRef fails.
 TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
   BinaryStreamReader R(*S);
   StringRef Str;
-  EXPECT_NO_ERROR(R.readFixedString(Str, 1));
+  EXPECT_THAT_ERROR(R.readFixedString(Str, 1), Succeeded());
   EXPECT_EQ(Str, StringRef("A"));
   EXPECT_EQ(0U, F.Allocator.getBytesAllocated());
 }
 
 // Tests that a read which is not aligned on the same boundary as a previous
 // cached request, but which is known to overlap that request, shares the
 // previous allocation.
 TEST(MappedBlockStreamTest, UnalignedOverlappingRead) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
   BinaryStreamReader R(*S);
   StringRef Str1;
   StringRef Str2;
-  EXPECT_NO_ERROR(R.readFixedString(Str1, 7));
+  EXPECT_THAT_ERROR(R.readFixedString(Str1, 7), Succeeded());
   EXPECT_EQ(Str1, StringRef("ABCDEFG"));
   EXPECT_EQ(7U, F.Allocator.getBytesAllocated());
 
   R.setOffset(2);
-  EXPECT_NO_ERROR(R.readFixedString(Str2, 3));
+  EXPECT_THAT_ERROR(R.readFixedString(Str2, 3), Succeeded());
   EXPECT_EQ(Str2, StringRef("CDE"));
   EXPECT_EQ(Str1.data() + 2, Str2.data());
   EXPECT_EQ(7U, F.Allocator.getBytesAllocated());
 }
 
 // Tests that a read which is not aligned on the same boundary as a previous
 // cached request, but which only partially overlaps a previous cached request,
 // still works correctly and allocates again from the shared pool.
 TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) {
   DiscontiguousStream F(BlocksAry, DataAry);
   auto S = MappedBlockStream::createStream(F.block_size(), F.layout(), F,
                                            F.Allocator);
   BinaryStreamReader R(*S);
   StringRef Str1;
   StringRef Str2;
-  EXPECT_NO_ERROR(R.readFixedString(Str1, 6));
+  EXPECT_THAT_ERROR(R.readFixedString(Str1, 6), Succeeded());
   EXPECT_EQ(Str1, StringRef("ABCDEF"));
   EXPECT_EQ(6U, F.Allocator.getBytesAllocated());
 
   R.setOffset(4);
-  EXPECT_NO_ERROR(R.readFixedString(Str2, 4));
+  EXPECT_THAT_ERROR(R.readFixedString(Str2, 4), Succeeded());
   EXPECT_EQ(Str2, StringRef("EFGH"));
   EXPECT_EQ(10U, F.Allocator.getBytesAllocated());
 }
 
 TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) {
   static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
   static uint8_t LargeBuffer[] = {'0', '1', '2', '3', '4', '5',
                                   '6', '7', '8', '9', 'A'};
   static uint8_t SmallBuffer[] = {'0', '1', '2'};
   static_assert(sizeof(LargeBuffer) > sizeof(Data),
                 "LargeBuffer is not big enough");
 
   DiscontiguousStream F(BlocksAry, Data);
   auto S = WritableMappedBlockStream::createStream(F.block_size(), F.layout(),
                                                    F, F.Allocator);
   ArrayRef<uint8_t> Buffer;
 
-  EXPECT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>(LargeBuffer)));
-  EXPECT_NO_ERROR(S->writeBytes(0, ArrayRef<uint8_t>(SmallBuffer)));
-  EXPECT_NO_ERROR(S->writeBytes(7, ArrayRef<uint8_t>(SmallBuffer)));
-  EXPECT_ERROR(S->writeBytes(8, ArrayRef<uint8_t>(SmallBuffer)));
+  EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>(LargeBuffer)), Failed());
+  EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>(SmallBuffer)),
+                    Succeeded());
+  EXPECT_THAT_ERROR(S->writeBytes(7, ArrayRef<uint8_t>(SmallBuffer)),
+                    Succeeded());
+  EXPECT_THAT_ERROR(S->writeBytes(8, ArrayRef<uint8_t>(SmallBuffer)), Failed());
 }
 
 TEST(MappedBlockStreamTest, TestWriteBytesNoBreakBoundary) {
   static uint8_t Data[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
   DiscontiguousStream F(BlocksAry, Data);
   auto S = WritableMappedBlockStream::createStream(F.block_size(), F.layout(),
                                                    F, F.Allocator);
   ArrayRef<uint8_t> Buffer;
 
-  EXPECT_NO_ERROR(S->readBytes(0, 1, Buffer));
+  EXPECT_THAT_ERROR(S->readBytes(0, 1, Buffer), Succeeded());
   EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
-  EXPECT_NO_ERROR(S->readBytes(9, 1, Buffer));
+  EXPECT_THAT_ERROR(S->readBytes(9, 1, Buffer), Succeeded());
   EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
 
-  EXPECT_NO_ERROR(S->writeBytes(0, ArrayRef<uint8_t>('J')));
-  EXPECT_NO_ERROR(S->writeBytes(9, ArrayRef<uint8_t>('A')));
+  EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>('J')), Succeeded());
+  EXPECT_THAT_ERROR(S->writeBytes(9, ArrayRef<uint8_t>('A')), Succeeded());
 
-  EXPECT_NO_ERROR(S->readBytes(0, 1, Buffer));
+  EXPECT_THAT_ERROR(S->readBytes(0, 1, Buffer), Succeeded());
   EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
-  EXPECT_NO_ERROR(S->readBytes(9, 1, Buffer));
+  EXPECT_THAT_ERROR(S->readBytes(9, 1, Buffer), Succeeded());
   EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
 
-  EXPECT_NO_ERROR(S->writeBytes(0, ArrayRef<uint8_t>('A')));
-  EXPECT_NO_ERROR(S->writeBytes(9, ArrayRef<uint8_t>('J')));
+  EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef<uint8_t>('A')), Succeeded());
+  EXPECT_THAT_ERROR(S->writeBytes(9, ArrayRef<uint8_t>('J')), Succeeded());
 
-  EXPECT_NO_ERROR(S->readBytes(0, 1, Buffer));
+  EXPECT_THAT_ERROR(S->readBytes(0, 1, Buffer), Succeeded());
   EXPECT_EQ(Buffer, ArrayRef<uint8_t>('A'));
-  EXPECT_NO_ERROR(S->readBytes(9, 1, Buffer));
+  EXPECT_THAT_ERROR(S->readBytes(9, 1, Buffer), Succeeded());
   EXPECT_EQ(Buffer, ArrayRef<uint8_t>('J'));
 }
 
 TEST(MappedBlockStreamTest, TestWriteBytesBreakBoundary) {
   static uint8_t Data[] = {'0', '0', '0', '0', '0', '0', '0', '0', '0', '0'};
   static uint8_t TestData[] = {'T', 'E', 'S', 'T', 'I', 'N', 'G', '.'};
   static uint8_t Expected[] = {'T', 'E', 'S', 'N', 'I',
                                'T', 'G', '.', '0', '0'};
 
   DiscontiguousStream F(BlocksAry, Data);
   auto S = WritableMappedBlockStream::createStream(F.block_size(), F.layout(),
                                                    F, F.Allocator);
   ArrayRef<uint8_t> Buffer;
 
-  EXPECT_NO_ERROR(S->writeBytes(0, TestData));
+  EXPECT_THAT_ERROR(S->writeBytes(0, TestData), Succeeded());
   // First just compare the memory, then compare the result of reading the
   // string out.
   EXPECT_EQ(ArrayRef<uint8_t>(Data), ArrayRef<uint8_t>(Expected));
 
-  EXPECT_NO_ERROR(S->readBytes(0, 8, Buffer));
+  EXPECT_THAT_ERROR(S->readBytes(0, 8, Buffer), Succeeded());
   EXPECT_EQ(Buffer, ArrayRef<uint8_t>(TestData));
 }
 
 TEST(MappedBlockStreamTest, TestWriteThenRead) {
   std::vector<uint8_t> DataBytes(10);
   MutableArrayRef<uint8_t> Data(DataBytes);
   const uint32_t Blocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
 
TEST(MappedBlockStreamTest, TestWriteThenRead) {
   ArrayRef<uint8_t> byteArrayRef1(byteArray1);
   ArrayRef<uint8_t> byteArray[] = { byteArrayRef0, byteArrayRef1 };
   uint32_t intArr0[] = {890723408, 29082234};
   uint32_t intArr1[] = {890723408, 29082234};
   ArrayRef<uint32_t> intArray[] = {intArr0, intArr1};
 
   BinaryStreamReader Reader(*S);
   BinaryStreamWriter Writer(*S);
-  EXPECT_NO_ERROR(Writer.writeInteger(u16[0]));
-  EXPECT_NO_ERROR(Reader.readInteger(u16[1]));
+  EXPECT_THAT_ERROR(Writer.writeInteger(u16[0]), Succeeded());
+  EXPECT_THAT_ERROR(Reader.readInteger(u16[1]), Succeeded());
   EXPECT_EQ(u16[0], u16[1]);
   EXPECT_EQ(std::vector<uint8_t>({0, 0x7A, 0xEC, 0, 0, 0, 0, 0, 0, 0}),
             DataBytes);
 
   Reader.setOffset(0);
   Writer.setOffset(0);
   ::memset(DataBytes.data(), 0, 10);
-  EXPECT_NO_ERROR(Writer.writeInteger(u32[0]));
-  EXPECT_NO_ERROR(Reader.readInteger(u32[1]));
+  EXPECT_THAT_ERROR(Writer.writeInteger(u32[0]), Succeeded());
+  EXPECT_THAT_ERROR(Reader.readInteger(u32[1]), Succeeded());
   EXPECT_EQ(u32[0], u32[1]);
   EXPECT_EQ(std::vector<uint8_t>({0x17, 0x5C, 0x50, 0, 0, 0, 0x35, 0, 0, 0}),
             DataBytes);
 
   Reader.setOffset(0);
   Writer.setOffset(0);
   ::memset(DataBytes.data(), 0, 10);
-  EXPECT_NO_ERROR(Writer.writeEnum(Enum[0]));
-  EXPECT_NO_ERROR(Reader.readEnum(Enum[1]));
+  EXPECT_THAT_ERROR(Writer.writeEnum(Enum[0]), Succeeded());
+  EXPECT_THAT_ERROR(Reader.readEnum(Enum[1]), Succeeded());
   EXPECT_EQ(Enum[0], Enum[1]);
   EXPECT_EQ(std::vector<uint8_t>({0x2C, 0x60, 0x4A, 0, 0, 0, 0, 0, 0, 0}),
             DataBytes);
 
   Reader.setOffset(0);
   Writer.setOffset(0);
   ::memset(DataBytes.data(), 0, 10);
-  EXPECT_NO_ERROR(Writer.writeCString(ZStr[0]));
-  EXPECT_NO_ERROR(Reader.readCString(ZStr[1]));
+  EXPECT_THAT_ERROR(Writer.writeCString(ZStr[0]), Succeeded());
+  EXPECT_THAT_ERROR(Reader.readCString(ZStr[1]), Succeeded());
   EXPECT_EQ(ZStr[0], ZStr[1]);
   EXPECT_EQ(
       std::vector<uint8_t>({'r', 'e', 'Z', ' ', 'S', 't', 'o', 'r', 0, 0}),
       DataBytes);
 
   Reader.setOffset(0);
   Writer.setOffset(0);
   ::memset(DataBytes.data(), 0, 10);
-  EXPECT_NO_ERROR(Writer.writeFixedString(FStr[0]));
-  EXPECT_NO_ERROR(Reader.readFixedString(FStr[1], FStr[0].size()));
+  EXPECT_THAT_ERROR(Writer.writeFixedString(FStr[0]), Succeeded());
+  EXPECT_THAT_ERROR(Reader.readFixedString(FStr[1], FStr[0].size()),
+                    Succeeded());
   EXPECT_EQ(FStr[0], FStr[1]);
   EXPECT_EQ(
       std::vector<uint8_t>({'x', 'i', 'F', 'd', ' ', 'S', 'e', 't', 0, 'r'}),
       DataBytes);
 
   Reader.setOffset(0);
   Writer.setOffset(0);
   ::memset(DataBytes.data(), 0, 10);
-  EXPECT_NO_ERROR(Writer.writeArray(byteArray[0]));
-  EXPECT_NO_ERROR(Reader.readArray(byteArray[1], byteArray[0].size()));
+  EXPECT_THAT_ERROR(Writer.writeArray(byteArray[0]), Succeeded());
+  EXPECT_THAT_ERROR(Reader.readArray(byteArray[1], byteArray[0].size()),
+                    Succeeded());
   EXPECT_EQ(byteArray[0], byteArray[1]);
   EXPECT_EQ(std::vector<uint8_t>({0, 0x32, 0x31, 0, 0, 0, 0, 0, 0, 0}),
             DataBytes);
 
   Reader.setOffset(0);
   Writer.setOffset(0);
   ::memset(DataBytes.data(), 0, 10);
-  EXPECT_NO_ERROR(Writer.writeArray(intArray[0]));
-  EXPECT_NO_ERROR(Reader.readArray(intArray[1], intArray[0].size()));
+  EXPECT_THAT_ERROR(Writer.writeArray(intArray[0]), Succeeded());
+  EXPECT_THAT_ERROR(Reader.readArray(intArray[1], intArray[0].size()),
+                    Succeeded());
   EXPECT_EQ(intArray[0], intArray[1]);
 }
 
 TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) {
   std::vector<uint8_t> DestDataBytes(10);
   MutableArrayRef<uint8_t> DestData(DestDataBytes);
   const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
 
   std::vector<uint8_t> SrcDataBytes(10);
   MutableArrayRef<uint8_t> SrcData(SrcDataBytes);
 
   DiscontiguousStream F(DestBlocks, DestData);
   auto DestStream = WritableMappedBlockStream::createStream(
       F.block_size(), F.layout(), F, F.Allocator);
 
   // First write "Test Str" into the source stream.
   MutableBinaryByteStream SourceStream(SrcData, little);
   BinaryStreamWriter SourceWriter(SourceStream);
-  EXPECT_NO_ERROR(SourceWriter.writeCString("Test Str"));
+  EXPECT_THAT_ERROR(SourceWriter.writeCString("Test Str"), Succeeded());
   EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
                               {'T', 'e', 's', 't', ' ', 'S', 't', 'r', 0, 0}));
 
   // Then write the source stream into the dest stream.
   BinaryStreamWriter DestWriter(*DestStream);
-  EXPECT_NO_ERROR(DestWriter.writeStreamRef(SourceStream));
+  EXPECT_THAT_ERROR(DestWriter.writeStreamRef(SourceStream), Succeeded());
   EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
                                {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0}));
 
   // Then read the string back out of the dest stream.
   StringRef Result;
   BinaryStreamReader DestReader(*DestStream);
-  EXPECT_NO_ERROR(DestReader.readCString(Result));
+  EXPECT_THAT_ERROR(DestReader.readCString(Result), Succeeded());
   EXPECT_EQ(Result, "Test Str");
 }
 
 TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) {
   std::vector<uint8_t> DestDataBytes(10);
   MutableArrayRef<uint8_t> DestData(DestDataBytes);
   const uint32_t DestBlocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
 
   std::vector<uint8_t> SrcDataBytes(10);
   MutableArrayRef<uint8_t> SrcData(SrcDataBytes);
   const uint32_t SrcBlocks[] = {1, 0, 6, 3, 4, 5, 2, 7, 8, 9};
 
   DiscontiguousStream DestF(DestBlocks, DestData);
   DiscontiguousStream SrcF(SrcBlocks, SrcData);
 
   auto Dest = WritableMappedBlockStream::createStream(
       DestF.block_size(), DestF.layout(), DestF, DestF.Allocator);
   auto Src = WritableMappedBlockStream::createStream(
       SrcF.block_size(), SrcF.layout(), SrcF, SrcF.Allocator);
 
   // First write "Test Str" into the source stream.
   BinaryStreamWriter SourceWriter(*Src);
-  EXPECT_NO_ERROR(SourceWriter.writeCString("Test Str"));
+  EXPECT_THAT_ERROR(SourceWriter.writeCString("Test Str"), Succeeded());
   EXPECT_EQ(SrcDataBytes, std::vector<uint8_t>(
                               {'e', 'T', 't', 't', ' ', 'S', 's', 'r', 0, 0}));
 
   // Then write the source stream into the dest stream.
   BinaryStreamWriter DestWriter(*Dest);
-  EXPECT_NO_ERROR(DestWriter.writeStreamRef(*Src));
+  EXPECT_THAT_ERROR(DestWriter.writeStreamRef(*Src), Succeeded());
   EXPECT_EQ(DestDataBytes, std::vector<uint8_t>(
                                {'s', 'e', 'T', ' ', 'S', 't', 't', 'r', 0, 0}));
 
   // Then read the string back out of the dest stream.
   StringRef Result;
   BinaryStreamReader DestReader(*Dest);
-  EXPECT_NO_ERROR(DestReader.readCString(Result));
+  EXPECT_THAT_ERROR(DestReader.readCString(Result), Succeeded());
   EXPECT_EQ(Result, "Test Str");
 }
 
 TEST(MappedBlockStreamTest, DataLivesAfterStreamDestruction) {
   std::vector<uint8_t> DataBytes(10);
   MutableArrayRef<uint8_t> Data(DataBytes);
   const uint32_t Blocks[] = {2, 1, 0, 6, 3, 4, 5, 7, 9, 8};
 
   StringRef Str[] = {"Zero Str", ""};
 
   DiscontiguousStream F(Blocks, Data);
   {
     auto S = WritableMappedBlockStream::createStream(F.block_size(), F.layout(),
                                                      F, F.Allocator);
 
     BinaryStreamReader Reader(*S);
     BinaryStreamWriter Writer(*S);
     ::memset(DataBytes.data(), 0, 10);
-    EXPECT_NO_ERROR(Writer.writeCString(Str[0]));
-    EXPECT_NO_ERROR(Reader.readCString(Str[1]));
+    EXPECT_THAT_ERROR(Writer.writeCString(Str[0]), Succeeded());
+    EXPECT_THAT_ERROR(Reader.readCString(Str[1]), Succeeded());
     EXPECT_EQ(Str[0], Str[1]);
   }
 
   EXPECT_EQ(Str[0], Str[1]);
 }
 
 } // end anonymous namespace

llvm/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp

 //===- StringTableBuilderTest.cpp -----------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ErrorChecking.h"
-
 #include "llvm/DebugInfo/PDB/Native/PDBStringTable.h"
 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 
+#include "UnitTestHelpers/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 using namespace llvm::support;
 
 namespace {
 class StringTableBuilderTest : public ::testing::Test {};
 }
 
 TEST_F(StringTableBuilderTest, Simple) {
   // Create /names table contents.
   PDBStringTableBuilder Builder;
   EXPECT_EQ(1U, Builder.insert("foo"));
   EXPECT_EQ(5U, Builder.insert("bar"));
   EXPECT_EQ(1U, Builder.insert("foo"));
   EXPECT_EQ(9U, Builder.insert("baz"));
 
   std::vector<uint8_t> Buffer(Builder.calculateSerializedSize());
   MutableBinaryByteStream OutStream(Buffer, little);
   BinaryStreamWriter Writer(OutStream);
-  EXPECT_NO_ERROR(Builder.commit(Writer));
+  EXPECT_THAT_ERROR(Builder.commit(Writer), Succeeded());
 
   // Reads the contents back.
   BinaryByteStream InStream(Buffer, little);
   BinaryStreamReader Reader(InStream);
   PDBStringTable Table;
-  EXPECT_NO_ERROR(Table.reload(Reader));
+  EXPECT_THAT_ERROR(Table.reload(Reader), Succeeded());
 
   EXPECT_EQ(3U, Table.getNameCount());
   EXPECT_EQ(1U, Table.getHashVersion());
 
-  EXPECT_EXPECTED_EQ("foo", Table.getStringForID(1));
-  EXPECT_EXPECTED_EQ("bar", Table.getStringForID(5));
-  EXPECT_EXPECTED_EQ("baz", Table.getStringForID(9));
-  EXPECT_EXPECTED_EQ(1U, Table.getIDForString("foo"));
-  EXPECT_EXPECTED_EQ(5U, Table.getIDForString("bar"));
-  EXPECT_EXPECTED_EQ(9U, Table.getIDForString("baz"));
+  EXPECT_THAT_EXPECTED(Table.getStringForID(1), HasValue("foo"));
+  EXPECT_THAT_EXPECTED(Table.getStringForID(5), HasValue("bar"));
+  EXPECT_THAT_EXPECTED(Table.getStringForID(9), HasValue("baz"));
+  EXPECT_THAT_EXPECTED(Table.getIDForString("foo"), HasValue(1U));
+  EXPECT_THAT_EXPECTED(Table.getIDForString("bar"), HasValue(5U));
+  EXPECT_THAT_EXPECTED(Table.getIDForString("baz"), HasValue(9U));
 }

llvm/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp

 //===- llvm/unittest/DebugInfo/PDB/TypeServerHandlerTest.cpp --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ErrorChecking.h"
-
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
 #include "llvm/DebugInfo/CodeView/TypeSerializer.h"
 #include "llvm/DebugInfo/CodeView/TypeServerHandler.h"
 #include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Error.h"
 
+#include "UnitTestHelpers/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 namespace {
 

 TEST_F(TypeServerHandlerTest, VisitRecordNoTypeServer) {
   MockTypeVisitorCallbacks C2;
   MockTypeVisitorCallbacks C1;
   TypeVisitorCallbackPipeline Pipeline;
 
   Pipeline.addCallbackToPipeline(C1);
   Pipeline.addCallbackToPipeline(C2);
 
-  EXPECT_NO_ERROR(codeview::visitTypeRecord(TypeServerRecord, Pipeline));
+  EXPECT_THAT_ERROR(codeview::visitTypeRecord(TypeServerRecord, Pipeline),
+                    Succeeded());
 
   EXPECT_EQ(MockTypeVisitorCallbacks::State::VisitTypeEnd, C1.S);
   EXPECT_EQ(MockTypeVisitorCallbacks::State::VisitTypeEnd, C2.S);
 }
 
 // Test that when a TypeServerHandler is registered, it gets consumed by the
 // handler if and only if the handler returns true.
 TEST_F(TypeServerHandlerTest, VisitRecordWithTypeServerOnce) {
   MockTypeServerHandler Handler(false);
 
   MockTypeVisitorCallbacks C1;
 
   // Our mock server returns true the first time.
-  EXPECT_NO_ERROR(codeview::visitTypeRecord(
-      TypeServerRecord, C1, codeview::VDS_BytesExternal, &Handler));
+  EXPECT_THAT_ERROR(codeview::visitTypeRecord(TypeServerRecord, C1,
+                                              codeview::VDS_BytesExternal,
+                                              &Handler),
+                    Succeeded());
   EXPECT_TRUE(Handler.Handled);
   EXPECT_EQ(MockTypeVisitorCallbacks::State::Ready, C1.S);
 
   // And false the second time.
-  EXPECT_NO_ERROR(codeview::visitTypeRecord(
-      TypeServerRecord, C1, codeview::VDS_BytesExternal, &Handler));
+  EXPECT_THAT_ERROR(codeview::visitTypeRecord(TypeServerRecord, C1,
+                                              codeview::VDS_BytesExternal,
+                                              &Handler),
+                    Succeeded());
   EXPECT_TRUE(Handler.Handled);
   EXPECT_EQ(MockTypeVisitorCallbacks::State::VisitTypeEnd, C1.S);
 }
 
 // Test that when a type server handler is registered, if the handler keeps
 // returning true, it will keep getting consumed by the handler and not go
 // to the default processor.
 TEST_F(TypeServerHandlerTest, VisitRecordWithTypeServerAlways) {
   MockTypeServerHandler Handler(true);
 
   MockTypeVisitorCallbacks C1;
 
-  EXPECT_NO_ERROR(codeview::visitTypeRecord(
-      TypeServerRecord, C1, codeview::VDS_BytesExternal, &Handler));
+  EXPECT_THAT_ERROR(codeview::visitTypeRecord(TypeServerRecord, C1,
+                                              codeview::VDS_BytesExternal,
+                                              &Handler),
+                    Succeeded());
   EXPECT_TRUE(Handler.Handled);
   EXPECT_EQ(MockTypeVisitorCallbacks::State::Ready, C1.S);
 
-  EXPECT_NO_ERROR(codeview::visitTypeRecord(
-      TypeServerRecord, C1, codeview::VDS_BytesExternal, &Handler));
+  EXPECT_THAT_ERROR(codeview::visitTypeRecord(TypeServerRecord, C1,
+                                              codeview::VDS_BytesExternal,
+                                              &Handler),
+                    Succeeded());
   EXPECT_TRUE(Handler.Handled);
   EXPECT_EQ(MockTypeVisitorCallbacks::State::Ready, C1.S);
 }
 
 } // end anonymous namespace

llvm/unittests/Support/BinaryStreamTest.cpp

 //===- llvm/unittest/Support/BinaryStreamTest.cpp -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "UnitTestHelpers/Error.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryItemStream.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 #include "gtest/gtest.h"
 
 #include <unordered_map>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::support;
 
-#define EXPECT_NO_ERROR(Err)                                                   \
-  {                                                                            \
-    auto E = Err;                                                              \
-    EXPECT_FALSE(static_cast<bool>(E));                                        \
-    if (E)                                                                     \
-      consumeError(std::move(E));                                              \
-  }
-
-#define ASSERT_NO_ERROR(Err)                                                   \
-  {                                                                            \
-    auto E = Err;                                                              \
-    ASSERT_FALSE(static_cast<bool>(E));                                        \
-    if (E)                                                                     \
-      consumeError(std::move(E));                                              \
-  }
-
-#define EXPECT_ERROR(Err)                                                      \
-  {                                                                            \
-    auto E = Err;                                                              \
-    EXPECT_TRUE(static_cast<bool>(E));                                         \
-    if (E)                                                                     \
-      consumeError(std::move(E));                                              \
-  }
-
 namespace {
 
 class BrokenStream : public WritableBinaryStream {
 public:
   BrokenStream(MutableArrayRef<uint8_t> Data, endianness Endian,
                       uint32_t Align)
       : Data(Data), PartitionIndex(alignDown(Data.size() / 2, Align)),
         Endian(Endian) {}
TEST_F(BinaryStreamTest, BinaryByteStreamBounds) {
   std::vector<uint8_t> InputData = {1, 2, 3, 4, 5};
   initializeInput(InputData, 1);
 
   for (auto &Stream : Streams) {
     ArrayRef<uint8_t> Buffer;
 
     // 1. If the read fits it should work.
     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
-    ASSERT_NO_ERROR(Stream.Input->readBytes(2, 1, Buffer));
+    ASSERT_THAT_ERROR(Stream.Input->readBytes(2, 1, Buffer), Succeeded());
     EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer);
-    ASSERT_NO_ERROR(Stream.Input->readBytes(0, 4, Buffer));
+    ASSERT_THAT_ERROR(Stream.Input->readBytes(0, 4, Buffer), Succeeded());
     EXPECT_EQ(makeArrayRef(InputData).slice(0, 4), Buffer);
 
     // 2. Reading past the bounds of the input should fail.
-    EXPECT_ERROR(Stream.Input->readBytes(4, 2, Buffer));
+    EXPECT_THAT_ERROR(Stream.Input->readBytes(4, 2, Buffer), Failed());
   }
 }
 
 TEST_F(BinaryStreamTest, StreamRefBounds) {
   std::vector<uint8_t> InputData = {1, 2, 3, 4, 5};
   initializeInput(InputData, 1);
 
   for (const auto &Stream : Streams) {
     ArrayRef<uint8_t> Buffer;
     BinaryStreamRef Ref(*Stream.Input);
 
     // Read 1 byte from offset 2 should work
     ASSERT_EQ(InputData.size(), Ref.getLength());
-    ASSERT_NO_ERROR(Ref.readBytes(2, 1, Buffer));
+    ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded());
     EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer);
 
     // Reading everything from offset 2 on.
-    ASSERT_NO_ERROR(Ref.readLongestContiguousChunk(2, Buffer));
+    ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
     if (Stream.IsContiguous)
       EXPECT_EQ(makeArrayRef(InputData).slice(2), Buffer);
     else
       EXPECT_FALSE(Buffer.empty());
 
     // Reading 6 bytes from offset 0 is too big.
-    EXPECT_ERROR(Ref.readBytes(0, 6, Buffer));
-    EXPECT_ERROR(Ref.readLongestContiguousChunk(6, Buffer));
+    EXPECT_THAT_ERROR(Ref.readBytes(0, 6, Buffer), Failed());
+    EXPECT_THAT_ERROR(Ref.readLongestContiguousChunk(6, Buffer), Failed());
 
     // Reading 1 byte from offset 2 after dropping 1 byte is the same as reading
     // 1 byte from offset 3.
     Ref = Ref.drop_front(1);
-    ASSERT_NO_ERROR(Ref.readBytes(2, 1, Buffer));
+    ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded());
     if (Stream.IsContiguous)
       EXPECT_EQ(makeArrayRef(InputData).slice(3, 1), Buffer);
     else
       EXPECT_FALSE(Buffer.empty());
 
     // Reading everything from offset 2 on after dropping 1 byte.
-    ASSERT_NO_ERROR(Ref.readLongestContiguousChunk(2, Buffer));
+    ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
     if (Stream.IsContiguous)
       EXPECT_EQ(makeArrayRef(InputData).slice(3), Buffer);
     else
       EXPECT_FALSE(Buffer.empty());
 
     // Reading 2 bytes from offset 2 after dropping 2 bytes is the same as
     // reading 2 bytes from offset 4, and should fail.
     Ref = Ref.drop_front(1);
-    EXPECT_ERROR(Ref.readBytes(2, 2, Buffer));
+    EXPECT_THAT_ERROR(Ref.readBytes(2, 2, Buffer), Failed());
 
     // But if we read the longest contiguous chunk instead, we should still
     // get the 1 byte at the end.
-    ASSERT_NO_ERROR(Ref.readLongestContiguousChunk(2, Buffer));
+    ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded());
     EXPECT_EQ(makeArrayRef(InputData).take_back(), Buffer);
   }
 }
 
 TEST_F(BinaryStreamTest, DropOperations) {
   std::vector<uint8_t> InputData = {1, 2, 3, 4, 5, 4, 3, 2, 1};
   auto RefData = makeArrayRef(InputData);
   initializeInput(InputData, 1);
 
   ArrayRef<uint8_t> Result;
   BinaryStreamRef Original(InputData, support::little);
   ASSERT_EQ(InputData.size(), Original.getLength());
 
-  EXPECT_NO_ERROR(Original.readBytes(0, InputData.size(), Result));
+  EXPECT_THAT_ERROR(Original.readBytes(0, InputData.size(), Result),
+                    Succeeded());
   EXPECT_EQ(RefData, Result);
 
   auto Dropped = Original.drop_front(2);
-  EXPECT_NO_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result));
+  EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
+                    Succeeded());
   EXPECT_EQ(RefData.drop_front(2), Result);
 
   Dropped = Original.drop_back(2);
-  EXPECT_NO_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result));
+  EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
+                    Succeeded());
   EXPECT_EQ(RefData.drop_back(2), Result);
 
   Dropped = Original.keep_front(2);
-  EXPECT_NO_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result));
+  EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
+                    Succeeded());
   EXPECT_EQ(RefData.take_front(2), Result);
 
   Dropped = Original.keep_back(2);
-  EXPECT_NO_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result));
+  EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
+                    Succeeded());
   EXPECT_EQ(RefData.take_back(2), Result);
 
   Dropped = Original.drop_symmetric(2);
-  EXPECT_NO_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result));
+  EXPECT_THAT_ERROR(Dropped.readBytes(0, Dropped.getLength(), Result),
+                    Succeeded());
   EXPECT_EQ(RefData.drop_front(2).drop_back(2), Result);
 }
 
 // Test that we can write to a BinaryStream without a StreamWriter.
 TEST_F(BinaryStreamTest, MutableBinaryByteStreamBounds) {
   std::vector<uint8_t> InputData = {'T', 'e', 's', 't', '\0'};
   initializeInput(InputData, 1);
   initializeOutput(InputData.size(), 1);
 
   // For every combination of input stream and output stream.
   for (auto &Stream : Streams) {
     MutableArrayRef<uint8_t> Buffer;
     ASSERT_EQ(InputData.size(), Stream.Input->getLength());
 
     // 1. Try two reads that are supposed to work.  One from offset 0, and one
     // from the middle.
     uint32_t Offsets[] = {0, 3};
     for (auto Offset : Offsets) {
       uint32_t ExpectedSize = Stream.Input->getLength() - Offset;
 
       // Read everything from Offset until the end of the input data.
       ArrayRef<uint8_t> Data;
-      ASSERT_NO_ERROR(Stream.Input->readBytes(Offset, ExpectedSize, Data));
+      ASSERT_THAT_ERROR(Stream.Input->readBytes(Offset, ExpectedSize, Data),
+                        Succeeded());
       ASSERT_EQ(ExpectedSize, Data.size());
 
       // Then write it to the destination.
-      ASSERT_NO_ERROR(Stream.Output->writeBytes(0, Data));
+      ASSERT_THAT_ERROR(Stream.Output->writeBytes(0, Data), Succeeded());
 
       // Then we read back what we wrote, it should match the corresponding
       // slice of the original input data.
       ArrayRef<uint8_t> Data2;
-      ASSERT_NO_ERROR(Stream.Output->readBytes(Offset, ExpectedSize, Data2));
+      ASSERT_THAT_ERROR(Stream.Output->readBytes(Offset, ExpectedSize, Data2),
+                        Succeeded());
       EXPECT_EQ(makeArrayRef(InputData).drop_front(Offset), Data2);
     }
 
     std::vector<uint8_t> BigData = {0, 1, 2, 3, 4};
     // 2. If the write is too big, it should fail.
-    EXPECT_ERROR(Stream.Output->writeBytes(3, BigData));
+    EXPECT_THAT_ERROR(Stream.Output->writeBytes(3, BigData), Failed());
   }
 }
 
 // Test that FixedStreamArray works correctly.
 TEST_F(BinaryStreamTest, FixedStreamArray) {
   std::vector<uint32_t> Ints = {90823, 12908, 109823, 209823};
   ArrayRef<uint8_t> IntBytes(reinterpret_cast<uint8_t *>(Ints.data()),
                              Ints.size() * sizeof(uint32_t));

 TEST_F(BinaryStreamTest, StreamReaderBounds) {
   std::vector<uint8_t> Bytes;
 
   initializeInput(Bytes, 1);
   for (auto &Stream : Streams) {
     StringRef S;
     BinaryStreamReader Reader(*Stream.Input);
     EXPECT_EQ(0U, Reader.bytesRemaining());
-    EXPECT_ERROR(Reader.readFixedString(S, 1));
+    EXPECT_THAT_ERROR(Reader.readFixedString(S, 1), Failed());
   }
 
   Bytes.resize(5);
   initializeInput(Bytes, 1);
   for (auto &Stream : Streams) {
     StringRef S;
     BinaryStreamReader Reader(*Stream.Input);
     EXPECT_EQ(Bytes.size(), Reader.bytesRemaining());
-    EXPECT_NO_ERROR(Reader.readFixedString(S, 5));
-    EXPECT_ERROR(Reader.readFixedString(S, 6));
+    EXPECT_THAT_ERROR(Reader.readFixedString(S, 5), Succeeded());
+    EXPECT_THAT_ERROR(Reader.readFixedString(S, 6), Failed());
   }
 }
 
 TEST_F(BinaryStreamTest, StreamReaderIntegers) {
   support::ulittle64_t Little{908234};
   support::ubig32_t Big{28907823};
   short NS = 2897;
   int NI = -89723;
   unsigned long NUL = 902309023UL;
   constexpr uint32_t Size =
       sizeof(Little) + sizeof(Big) + sizeof(NS) + sizeof(NI) + sizeof(NUL);
 
   initializeOutput(Size, alignof(support::ulittle64_t));
   initializeInputFromOutput(alignof(support::ulittle64_t));
 
   for (auto &Stream : Streams) {
     BinaryStreamWriter Writer(*Stream.Output);
-    ASSERT_NO_ERROR(Writer.writeObject(Little));
-    ASSERT_NO_ERROR(Writer.writeObject(Big));
-    ASSERT_NO_ERROR(Writer.writeInteger(NS));
-    ASSERT_NO_ERROR(Writer.writeInteger(NI));
-    ASSERT_NO_ERROR(Writer.writeInteger(NUL));
+    ASSERT_THAT_ERROR(Writer.writeObject(Little), Succeeded());
+    ASSERT_THAT_ERROR(Writer.writeObject(Big), Succeeded());
+    ASSERT_THAT_ERROR(Writer.writeInteger(NS), Succeeded());
+    ASSERT_THAT_ERROR(Writer.writeInteger(NI), Succeeded());
+    ASSERT_THAT_ERROR(Writer.writeInteger(NUL), Succeeded());
 
     const support::ulittle64_t *Little2;
     const support::ubig32_t *Big2;
     short NS2;
     int NI2;
     unsigned long NUL2;
 
     // 1. Reading fields individually.
     BinaryStreamReader Reader(*Stream.Input);
-    ASSERT_NO_ERROR(Reader.readObject(Little2));
-    ASSERT_NO_ERROR(Reader.readObject(Big2));
-    ASSERT_NO_ERROR(Reader.readInteger(NS2));
-    ASSERT_NO_ERROR(Reader.readInteger(NI2));
-    ASSERT_NO_ERROR(Reader.readInteger(NUL2));
+    ASSERT_THAT_ERROR(Reader.readObject(Little2), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readObject(Big2), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readInteger(NS2), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readInteger(NI2), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readInteger(NUL2), Succeeded());
     ASSERT_EQ(0U, Reader.bytesRemaining());
 
     EXPECT_EQ(Little, *Little2);
     EXPECT_EQ(Big, *Big2);
     EXPECT_EQ(NS, NS2);
     EXPECT_EQ(NI, NI2);
     EXPECT_EQ(NUL, NUL2);
   }
 }
 
 TEST_F(BinaryStreamTest, StreamReaderIntegerArray) {
   // 1. Arrays of integers
   std::vector<int> Ints = {1, 2, 3, 4, 5};
   ArrayRef<uint8_t> IntBytes(reinterpret_cast<uint8_t *>(&Ints[0]),
                              Ints.size() * sizeof(int));
 
   initializeInput(IntBytes, alignof(int));
   for (auto &Stream : Streams) {
     BinaryStreamReader Reader(*Stream.Input);
     ArrayRef<int> IntsRef;
-    ASSERT_NO_ERROR(Reader.readArray(IntsRef, Ints.size()));
+    ASSERT_THAT_ERROR(Reader.readArray(IntsRef, Ints.size()), Succeeded());
     ASSERT_EQ(0U, Reader.bytesRemaining());
     EXPECT_EQ(makeArrayRef(Ints), IntsRef);
 
     Reader.setOffset(0);
     FixedStreamArray<int> FixedIntsRef;
-    ASSERT_NO_ERROR(Reader.readArray(FixedIntsRef, Ints.size()));
+    ASSERT_THAT_ERROR(Reader.readArray(FixedIntsRef, Ints.size()), Succeeded());
     ASSERT_EQ(0U, Reader.bytesRemaining());
     ASSERT_EQ(Ints, std::vector<int>(FixedIntsRef.begin(), FixedIntsRef.end()));
   }
 }
 
 TEST_F(BinaryStreamTest, StreamReaderEnum) {
   enum class MyEnum : int64_t { Foo = -10, Bar = 0, Baz = 10 };
 
   std::vector<MyEnum> Enums = {MyEnum::Bar, MyEnum::Baz, MyEnum::Foo};
 
   initializeOutput(Enums.size() * sizeof(MyEnum), alignof(MyEnum));
   initializeInputFromOutput(alignof(MyEnum));
   for (auto &Stream : Streams) {
     BinaryStreamWriter Writer(*Stream.Output);
     for (auto Value : Enums)
-      ASSERT_NO_ERROR(Writer.writeEnum(Value));
+      ASSERT_THAT_ERROR(Writer.writeEnum(Value), Succeeded());
 
     BinaryStreamReader Reader(*Stream.Input);
 
     ArrayRef<MyEnum> Array;
     FixedStreamArray<MyEnum> FSA;
 
     for (size_t I = 0; I < Enums.size(); ++I) {
       MyEnum Value;
-      ASSERT_NO_ERROR(Reader.readEnum(Value));
+      ASSERT_THAT_ERROR(Reader.readEnum(Value), Succeeded());
       EXPECT_EQ(Enums[I], Value);
     }
     ASSERT_EQ(0U, Reader.bytesRemaining());
   }
 }
 
 TEST_F(BinaryStreamTest, StreamReaderObject) {
   struct Foo {
TEST_F(BinaryStreamTest, StreamReaderObject) {
   initializeInput(makeArrayRef(Bytes, 3 * sizeof(Foo)), alignof(Foo));
 
   for (auto &Stream : Streams) {
     // 1. Reading object pointers.
     BinaryStreamReader Reader(*Stream.Input);
     const Foo *FPtrOut = nullptr;
     const Foo *GPtrOut = nullptr;
     const Foo *HPtrOut = nullptr;
-    ASSERT_NO_ERROR(Reader.readObject(FPtrOut));
-    ASSERT_NO_ERROR(Reader.readObject(GPtrOut));
-    ASSERT_NO_ERROR(Reader.readObject(HPtrOut));
+    ASSERT_THAT_ERROR(Reader.readObject(FPtrOut), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readObject(GPtrOut), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readObject(HPtrOut), Succeeded());
     EXPECT_EQ(0U, Reader.bytesRemaining());
     EXPECT_EQ(Foos[0], *FPtrOut);
     EXPECT_EQ(Foos[1], *GPtrOut);
     EXPECT_EQ(Foos[2], *HPtrOut);
   }
 }
 
 TEST_F(BinaryStreamTest, StreamReaderStrings) {
   std::vector<uint8_t> Bytes = {'O',  'n', 'e', '\0', 'T', 'w', 'o',
                                 '\0', 'T', 'h', 'r',  'e', 'e', '\0',
                                 'F',  'o', 'u', 'r',  '\0'};
   initializeInput(Bytes, 1);
 
   for (auto &Stream : Streams) {
     BinaryStreamReader Reader(*Stream.Input);
 
     StringRef S1;
     StringRef S2;
     StringRef S3;
     StringRef S4;
-    ASSERT_NO_ERROR(Reader.readCString(S1));
-    ASSERT_NO_ERROR(Reader.readCString(S2));
-    ASSERT_NO_ERROR(Reader.readCString(S3));
-    ASSERT_NO_ERROR(Reader.readCString(S4));
+    ASSERT_THAT_ERROR(Reader.readCString(S1), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readCString(S2), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readCString(S3), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readCString(S4), Succeeded());
     ASSERT_EQ(0U, Reader.bytesRemaining());
 
     EXPECT_EQ("One", S1);
     EXPECT_EQ("Two", S2);
     EXPECT_EQ("Three", S3);
     EXPECT_EQ("Four", S4);
 
     S1 = S2 = S3 = S4 = "";
     Reader.setOffset(0);
-    ASSERT_NO_ERROR(Reader.readFixedString(S1, 3));
-    ASSERT_NO_ERROR(Reader.skip(1));
-    ASSERT_NO_ERROR(Reader.readFixedString(S2, 3));
-    ASSERT_NO_ERROR(Reader.skip(1));
-    ASSERT_NO_ERROR(Reader.readFixedString(S3, 5));
-    ASSERT_NO_ERROR(Reader.skip(1));
-    ASSERT_NO_ERROR(Reader.readFixedString(S4, 4));
-    ASSERT_NO_ERROR(Reader.skip(1));
+    ASSERT_THAT_ERROR(Reader.readFixedString(S1, 3), Succeeded());
+    ASSERT_THAT_ERROR(Reader.skip(1), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readFixedString(S2, 3), Succeeded());
+    ASSERT_THAT_ERROR(Reader.skip(1), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readFixedString(S3, 5), Succeeded());
+    ASSERT_THAT_ERROR(Reader.skip(1), Succeeded());
+    ASSERT_THAT_ERROR(Reader.readFixedString(S4, 4), Succeeded());
+    ASSERT_THAT_ERROR(Reader.skip(1), Succeeded());
     ASSERT_EQ(0U, Reader.bytesRemaining());
 
     EXPECT_EQ("One", S1);
     EXPECT_EQ("Two", S2);
     EXPECT_EQ("Three", S3);
     EXPECT_EQ("Four", S4);
   }
 }
 
 TEST_F(BinaryStreamTest, StreamWriterBounds) {
   initializeOutput(5, 1);
 
   for (auto &Stream : Streams) {
     BinaryStreamWriter Writer(*Stream.Output);
 
     // 1. Can write a string that exactly fills the buffer.
     EXPECT_EQ(5U, Writer.bytesRemaining());
-    EXPECT_NO_ERROR(Writer.writeFixedString("abcde"));
+    EXPECT_THAT_ERROR(Writer.writeFixedString("abcde"), Succeeded());
     EXPECT_EQ(0U, Writer.bytesRemaining());
 
     // 2. Can write an empty string even when you're full
-    EXPECT_NO_ERROR(Writer.writeFixedString(""));
-    EXPECT_ERROR(Writer.writeFixedString("a"));
+    EXPECT_THAT_ERROR(Writer.writeFixedString(""), Succeeded());
+    EXPECT_THAT_ERROR(Writer.writeFixedString("a"), Failed());
 
     // 3. Can't write a string that is one character too long.
     Writer.setOffset(0);
-    EXPECT_ERROR(Writer.writeFixedString("abcdef"));
+    EXPECT_THAT_ERROR(Writer.writeFixedString("abcdef"), Failed());
   }
 }
 
 TEST_F(BinaryStreamTest, StreamWriterIntegerArrays) {
   // 3. Arrays of integers
   std::vector<int> SourceInts = {1, 2, 3, 4, 5};
   ArrayRef<uint8_t> SourceBytes(reinterpret_cast<uint8_t *>(&SourceInts[0]),
                                 SourceInts.size() * sizeof(int));
 
   initializeInput(SourceBytes, alignof(int));
   initializeOutputFromInput(alignof(int));
 
   for (auto &Stream : Streams) {
     BinaryStreamReader Reader(*Stream.Input);
     BinaryStreamWriter Writer(*Stream.Output);
     ArrayRef<int> Ints;
     ArrayRef<int> Ints2;
     // First read them, then write them, then read them back.
-    ASSERT_NO_ERROR(Reader.readArray(Ints, SourceInts.size()));
-    ASSERT_NO_ERROR(Writer.writeArray(Ints));
+    ASSERT_THAT_ERROR(Reader.readArray(Ints, SourceInts.size()), Succeeded());
+    ASSERT_THAT_ERROR(Writer.writeArray(Ints), Succeeded());
 
     BinaryStreamReader ReaderBacker(*Stream.Output);
-    ASSERT_NO_ERROR(ReaderBacker.readArray(Ints2, SourceInts.size()));
+    ASSERT_THAT_ERROR(ReaderBacker.readArray(Ints2, SourceInts.size()),
+                      Succeeded());
 
     EXPECT_EQ(makeArrayRef(SourceInts), Ints2);
   }
 }
 
 TEST_F(BinaryStreamTest, StringWriterStrings) {
   StringRef Strings[] = {"First", "Second", "Third", "Fourth"};
 
   size_t Length = 0;
   for (auto S : Strings)
     Length += S.size() + 1;
   initializeOutput(Length, 1);
   initializeInputFromOutput(1);
 
   for (auto &Stream : Streams) {
     BinaryStreamWriter Writer(*Stream.Output);
     for (auto S : Strings)
-      ASSERT_NO_ERROR(Writer.writeCString(S));
+      ASSERT_THAT_ERROR(Writer.writeCString(S), Succeeded());
     std::vector<StringRef> InStrings;
     BinaryStreamReader Reader(*Stream.Input);
     while (!Reader.empty()) {
       StringRef S;
-      ASSERT_NO_ERROR(Reader.readCString(S));
+      ASSERT_THAT_ERROR(Reader.readCString(S), Succeeded());
       InStrings.push_back(S);
     }
     EXPECT_EQ(makeArrayRef(Strings), makeArrayRef(InStrings));
   }
 }
 }
 
 namespace {
TEST_F(BinaryStreamTest, BinaryItemStream) {
   std::vector<Foo> Foos = {{1, 1.0}, {2, 2.0}, {3, 3.0}};
   BumpPtrAllocator Allocator;
   for (const auto &F : Foos) {
     uint8_t *Ptr = static_cast<uint8_t *>(Allocator.Allocate(sizeof(Foo),
                                                              alignof(Foo)));
     MutableArrayRef<uint8_t> Buffer(Ptr, sizeof(Foo));
     MutableBinaryByteStream Stream(Buffer, llvm::support::big);
     BinaryStreamWriter Writer(Stream);
-    ASSERT_NO_ERROR(Writer.writeObject(F));
+    ASSERT_THAT_ERROR(Writer.writeObject(F), Succeeded());
     Objects.push_back(BinaryItemStreamObject(Buffer));
   }
 
   BinaryItemStream<BinaryItemStreamObject> ItemStream(big);
   ItemStream.setItems(Objects);
   BinaryStreamReader Reader(ItemStream);
 
   for (const auto &F : Foos) {
     const Foo *F2;
-    ASSERT_NO_ERROR(Reader.readObject(F2));
+    ASSERT_THAT_ERROR(Reader.readObject(F2), Succeeded());
 
     EXPECT_EQ(F.X, F2->X);
     EXPECT_DOUBLE_EQ(F.Y, F2->Y);
   }
 }
 
 } // end anonymous namespace

llvm/unittests/Support/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
+  UnitTestHelpers
   )
 
 add_llvm_unittest(SupportTests
   AlignOfTest.cpp
   AllocatorTest.cpp
   ARMAttributeParser.cpp
   ArrayRecyclerTest.cpp
   BinaryStreamTest.cpp

llvm/utils/unittest/CMakeLists.txt

add_llvm_library(gtest
 
   LINK_COMPONENTS
   Support # Depends on llvm::raw_ostream
 
   # This is a library meant only for the build tree.
   BUILDTREE_ONLY
 )
 
+add_subdirectory(Helpers)
 add_subdirectory(UnitTestMain)

llvm/utils/unittest/Helpers/CMakeLists.txt

+add_subdirectory(UnitTestHelpers)

llvm/utils/unittest/Helpers/LLVMBuild.txt

+;===- ./utils/unittests/Helpers/UnitTestHelpers/LLVMBuild.txt --*- Conf -*--===;
+;
+;                     The LLVM Compiler Infrastructure
+;
+; This file is distributed under the University of Illinois Open Source
+; License. See LICENSE.TXT for details.
+;
+;===------------------------------------------------------------------------===;
+;
+; This is an LLVMBuild description file for the components in this subdirectory.
+;
+; For more information on the LLVMBuild system, please see:
+;
+;   http://llvm.org/docs/LLVMBuild.html
+;
+;===------------------------------------------------------------------------===;
+
+[common]
+subdirectories = UnitTestHelpers

llvm/utils/unittest/Helpers/UnitTestHelpers/CMakeLists.txt

+include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/Helpers/include)
+  
+add_llvm_library(LLVMUnitTestHelpers
+  Error.cpp
+  
+  ADDITIONAL_HEADER_DIRS
+  ${LLVM_MAIN_INCLUDE_DIR}/utils/unittest/Helpers/include
+  )

llvm/utils/unittest/Helpers/UnitTestHelpers/Error.cpp

+//===- UnittestHelpers/Error.cpp ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "UnitTestHelpers/Error.h"
+
+#include "llvm/ADT/StringRef.h"
+
+using namespace llvm;
+
+void llvm::detail::PrintTo(const ErrorHolder &Err, std::ostream *Out) {
+  *Out << (Err.Success ? "succeeded" : "failed");
+  if (!Err.Success) {
+    *Out << "  (" << StringRef(Err.Message).trim().str() << ")";
+  }
+}
+
+llvm::detail::ErrorHolder llvm::detail::TakeError(llvm::Error Err) {
+  bool Succeeded = !static_cast<bool>(Err);
+  std::string Message;
+  if (!Succeeded)
+    Message = toString(std::move(Err));
+  return {Succeeded, Message};
+}

llvm/utils/unittest/Helpers/UnitTestHelpers/LLVMBuild.txt

+;===- ./lib/LLVMBuild.txt --------------------------------------*- Conf -*--===;
+;
+;                     The LLVM Compiler Infrastructure
+;
+; This file is distributed under the University of Illinois Open Source
+; License. See LICENSE.TXT for details.
+;
+;===------------------------------------------------------------------------===;
+;
+; This is an LLVMBuild description file for the components in this subdirectory.
+;
+; For more information on the LLVMBuild system, please see:
+;
+;   http://llvm.org/docs/LLVMBuild.html
+;
+;===------------------------------------------------------------------------===;
+
+[component_0]
+type = Library
+name = UnitTestHelpers
+parent = Libraries
+required_libraries = Support

llvm/utils/unittest/Helpers/include/UnitTestHelpers/Error.h

+//===- UnittestHelpers/Error.cpp ------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_UTILS_UNITTESTHELPERS_ERROR_H
+#define LLVM_UTILS_UNITTESTHELPERS_ERROR_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/Error.h"
+
+#include "gmock/gmock.h"
+#include <ostream>
+
+namespace llvm {
+namespace detail {
+struct ErrorHolder {
+  bool Success;
+  std::string Message;
+};
+
+template <typename T> struct ExpectedHolder : public ErrorHolder {
+  Optional<T *> Value;
+};
+
+void PrintTo(const ErrorHolder &, std::ostream *Out);
+
+template <typename T>
+void PrintTo(const ExpectedHolder<T> &Item, std::ostream *Out) {
+  *Out << (Item.Success ? "succeeded" : "failed");
+  if (Item.Success) {
+    *Out << "succeeded (value = " << *Item.Value << ")";
+  } else {
+    PrintTo(static_cast<const ErrorHolder &>(Item), Out);
+  }
+}
+
+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;
+}
+
+template <typename T> ExpectedHolder<T> TakeExpected(const Expected<T> &Exp) {
+  return TakeExpected(const_cast<Expected<T> &>(Exp));
+}
+}
+
+#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, "") {
+  if (!arg.Success)
+    return false;
+  assert(arg.Value.hasValue());
+  return (**arg.Value == value);
+}
+}
+
+#endif

llvm/utils/unittest/LLVMBuild.txt

 ; This is an LLVMBuild description file for the components in this subdirectory.
 ;
 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
+[common]
+subdirectories = Helpers
+
 [component_0]
 type = Library
 name = gtest
 parent = Libraries
 required_libraries = Support
 installed = 0
 
 [component_1]
 type = Library
 name = gtest_main
 parent = Libraries
 required_libraries = gtest
 installed = 0
+