[gtest] Create a shared include directory for gtest utilities.
Many times unit tests for different libraries would like to use
the same helper functions for checking common types of errors.
This patch adds a common library with helpers for testing things
in Support, and introduces helpers in here for integrating the
llvm::Error and llvm::Expected<T> classes with gtest and gmock.
Normally, we would just be able to write:
EXPECT_THAT(someFunction(), succeeded());
but due to some quirks in llvm::Error's move semantics, gmock
doesn't make this easy, so two macros EXPECT_THAT_ERROR() and
EXPECT_THAT_EXPECTED() are introduced to gloss over the difficulties.
Consider this an exception, and possibly only temporary as we
look for ways to improve this.
Differential Revision: https://reviews.llvm.org/D33059
llvm-svn: 305395
diff --git a/llvm/unittests/DebugInfo/CodeView/CMakeLists.txt b/llvm/unittests/DebugInfo/CodeView/CMakeLists.txt
index aff3b6d..800f482 100644
--- a/llvm/unittests/DebugInfo/CodeView/CMakeLists.txt
+++ b/llvm/unittests/DebugInfo/CodeView/CMakeLists.txt
@@ -1,12 +1,13 @@
-set(LLVM_LINK_COMPONENTS
- DebugInfoCodeView
- )
-
-set(DebugInfoCodeViewSources
- RandomAccessVisitorTest.cpp
- TypeIndexDiscoveryTest.cpp
- )
-
-add_llvm_unittest(DebugInfoCodeViewTests
- ${DebugInfoCodeViewSources}
- )
+set(LLVM_LINK_COMPONENTS
+ DebugInfoCodeView
+ TestingSupport
+ )
+
+set(DebugInfoCodeViewSources
+ RandomAccessVisitorTest.cpp
+ TypeIndexDiscoveryTest.cpp
+ )
+
+add_llvm_unittest(DebugInfoCodeViewTests
+ ${DebugInfoCodeViewSources}
+ )
diff --git a/llvm/unittests/DebugInfo/CodeView/ErrorChecking.h b/llvm/unittests/DebugInfo/CodeView/ErrorChecking.h
deleted file mode 100644
index 4ca74c4..0000000
--- a/llvm/unittests/DebugInfo/CodeView/ErrorChecking.h
+++ /dev/null
@@ -1,70 +0,0 @@
-//===- 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
diff --git a/llvm/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp b/llvm/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp
index 0ca24c7..4fa172a 100644
--- a/llvm/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp
+++ b/llvm/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp
@@ -7,8 +7,6 @@
//
//===----------------------------------------------------------------------===//
-#include "ErrorChecking.h"
-
#include "llvm/ADT/SmallBitVector.h"
#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
@@ -22,6 +20,7 @@
#include "llvm/Support/Allocator.h"
#include "llvm/Support/BinaryItemStream.h"
#include "llvm/Support/Error.h"
+#include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h"
@@ -219,7 +218,8 @@
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
@@ -247,7 +247,8 @@
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]
@@ -275,7 +276,8 @@
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]
@@ -305,7 +307,8 @@
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.
@@ -334,7 +337,8 @@
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)
diff --git a/llvm/unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp b/llvm/unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp
index 4eca777..99c8490 100644
--- a/llvm/unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp
+++ b/llvm/unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp
@@ -9,7 +9,6 @@
#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
-#include "ErrorChecking.h"
#include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
#include "llvm/Support/Allocator.h"
diff --git a/llvm/unittests/DebugInfo/PDB/CMakeLists.txt b/llvm/unittests/DebugInfo/PDB/CMakeLists.txt
index cbbbd817..ce6dadf 100644
--- a/llvm/unittests/DebugInfo/PDB/CMakeLists.txt
+++ b/llvm/unittests/DebugInfo/PDB/CMakeLists.txt
@@ -2,6 +2,7 @@
DebugInfoCodeView
DebugInfoMSF
DebugInfoPDB
+ TestingSupport
)
set(DebugInfoPDBSources
diff --git a/llvm/unittests/DebugInfo/PDB/ErrorChecking.h b/llvm/unittests/DebugInfo/PDB/ErrorChecking.h
deleted file mode 100644
index f284bfd..0000000
--- a/llvm/unittests/DebugInfo/PDB/ErrorChecking.h
+++ /dev/null
@@ -1,61 +0,0 @@
-//===- 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
diff --git a/llvm/unittests/DebugInfo/PDB/HashTableTest.cpp b/llvm/unittests/DebugInfo/PDB/HashTableTest.cpp
index 94c9ee8..f1968e5 100644
--- a/llvm/unittests/DebugInfo/PDB/HashTableTest.cpp
+++ b/llvm/unittests/DebugInfo/PDB/HashTableTest.cpp
@@ -7,13 +7,13 @@
//
//===----------------------------------------------------------------------===//
-#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 "llvm/Testing/Support/Error.h"
+
+#include "gtest/gtest.h"
#include <vector>
@@ -150,13 +150,13 @@
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());
diff --git a/llvm/unittests/DebugInfo/PDB/MSFBuilderTest.cpp b/llvm/unittests/DebugInfo/PDB/MSFBuilderTest.cpp
index 5f2f0c2..23a15d1 100644
--- a/llvm/unittests/DebugInfo/PDB/MSFBuilderTest.cpp
+++ b/llvm/unittests/DebugInfo/PDB/MSFBuilderTest.cpp
@@ -7,10 +7,9 @@
//
//===----------------------------------------------------------------------===//
-#include "ErrorChecking.h"
-
#include "llvm/DebugInfo/MSF/MSFBuilder.h"
#include "llvm/DebugInfo/MSF/MSFCommon.h"
+#include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h"
@@ -46,7 +45,7 @@
SuperBlock SB;
initializeSuperBlock(SB);
- EXPECT_NO_ERROR(msf::validateSuperBlock(SB));
+ EXPECT_THAT_ERROR(msf::validateSuperBlock(SB), Succeeded());
}
TEST_F(MSFBuilderTest, ValidateSuperBlockReject) {
@@ -56,24 +55,24 @@
// 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) {
@@ -86,10 +85,11 @@
// 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));
@@ -106,28 +106,28 @@
// 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());
@@ -140,13 +140,14 @@
// 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());
@@ -156,15 +157,15 @@
// 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());
@@ -178,15 +179,15 @@
// 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());
@@ -199,15 +200,15 @@
// 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());
@@ -220,15 +221,15 @@
// 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());
@@ -240,20 +241,20 @@
// 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
@@ -263,7 +264,7 @@
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());
@@ -274,19 +275,19 @@
// 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);
@@ -305,15 +306,15 @@
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());
@@ -326,16 +327,16 @@
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]);
@@ -344,16 +345,16 @@
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));
+ ASSERT_THAT_EXPECTED(Msf.addStream(2048), Succeeded());
auto ExpectedLayout = Msf.build();
- EXPECT_EXPECTED(ExpectedLayout);
+ ASSERT_THAT_EXPECTED(ExpectedLayout, Succeeded());
MSFLayout &L = *ExpectedLayout;
EXPECT_EQ(1U, L.DirectoryBlocks.size());
EXPECT_EQ(B + 1, L.DirectoryBlocks[0]);
diff --git a/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp b/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
index 789fe51..a9a1ee4 100644
--- a/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
+++ b/llvm/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp
@@ -7,16 +7,16 @@
//
//===----------------------------------------------------------------------===//
-#include "ErrorChecking.h"
-
+#include "llvm/DebugInfo/MSF/MappedBlockStream.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 "llvm/Testing/Support/Error.h"
+
#include "gtest/gtest.h"
#include <unordered_map>
@@ -95,11 +95,11 @@
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
@@ -111,7 +111,7 @@
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());
}
@@ -125,12 +125,12 @@
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());
}
@@ -144,7 +144,7 @@
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());
}
@@ -159,7 +159,7 @@
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());
}
@@ -173,7 +173,7 @@
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());
}
@@ -186,7 +186,7 @@
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());
}
@@ -198,7 +198,7 @@
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());
}
@@ -213,12 +213,12 @@
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());
@@ -234,12 +234,12 @@
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());
}
@@ -257,10 +257,12 @@
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) {
@@ -270,25 +272,25 @@
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'));
}
@@ -303,12 +305,12 @@
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));
}
@@ -340,8 +342,8 @@
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);
@@ -349,8 +351,8 @@
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);
@@ -358,8 +360,8 @@
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);
@@ -367,8 +369,8 @@
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}),
@@ -377,8 +379,9 @@
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'}),
@@ -387,8 +390,9 @@
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);
@@ -396,8 +400,9 @@
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]);
}
@@ -416,20 +421,20 @@
// 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");
}
@@ -452,20 +457,20 @@
// 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");
}
@@ -484,8 +489,8 @@
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]);
}
diff --git a/llvm/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp b/llvm/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp
index 249bc4a..0efc2c6 100644
--- a/llvm/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp
+++ b/llvm/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp
@@ -7,13 +7,12 @@
//
//===----------------------------------------------------------------------===//
-#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 "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h"
@@ -36,21 +35,21 @@
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));
}
diff --git a/llvm/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp b/llvm/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp
index 1a30dad..d09b913 100644
--- a/llvm/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp
+++ b/llvm/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp
@@ -7,19 +7,18 @@
//
//===----------------------------------------------------------------------===//
-#include "ErrorChecking.h"
-
+#include "llvm/DebugInfo/CodeView/TypeServerHandler.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 "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h"
@@ -127,7 +126,8 @@
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);
@@ -141,14 +141,18 @@
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);
}
@@ -161,13 +165,17 @@
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);
}