From 7470585f23e61c45e0ccc6aab78d3b90169aa0a0 Mon Sep 17 00:00:00 2001 From: Zachary Turner Date: Wed, 14 Jun 2017 16:41:50 +0000 Subject: [PATCH] [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 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 --- include/llvm/Testing/Support/Error.h | 69 ++++++++ include/llvm/Testing/Support/SupportHelpers.h | 46 +++++ lib/CMakeLists.txt | 1 + lib/LLVMBuild.txt | 1 + lib/Testing/CMakeLists.txt | 1 + lib/Testing/LLVMBuild.txt | 19 ++ lib/Testing/Support/CMakeLists.txt | 12 ++ lib/Testing/Support/Error.cpp | 22 +++ lib/Testing/Support/LLVMBuild.txt | 22 +++ unittests/DebugInfo/CodeView/CMakeLists.txt | 25 +-- unittests/DebugInfo/CodeView/ErrorChecking.h | 70 -------- .../CodeView/RandomAccessVisitorTest.cpp | 18 +- .../CodeView/TypeIndexDiscoveryTest.cpp | 1 - unittests/DebugInfo/PDB/CMakeLists.txt | 1 + unittests/DebugInfo/PDB/ErrorChecking.h | 61 ------- unittests/DebugInfo/PDB/HashTableTest.cpp | 10 +- unittests/DebugInfo/PDB/MSFBuilderTest.cpp | 101 +++++------ .../DebugInfo/PDB/MappedBlockStreamTest.cpp | 119 +++++++------ .../DebugInfo/PDB/StringTableBuilderTest.cpp | 19 +- .../DebugInfo/PDB/TypeServerHandlerTest.cpp | 32 ++-- unittests/Support/BinaryStreamTest.cpp | 163 ++++++++---------- unittests/Support/CMakeLists.txt | 1 + 22 files changed, 441 insertions(+), 373 deletions(-) create mode 100644 include/llvm/Testing/Support/Error.h create mode 100644 include/llvm/Testing/Support/SupportHelpers.h create mode 100644 lib/Testing/CMakeLists.txt create mode 100644 lib/Testing/LLVMBuild.txt create mode 100644 lib/Testing/Support/CMakeLists.txt create mode 100644 lib/Testing/Support/Error.cpp create mode 100644 lib/Testing/Support/LLVMBuild.txt delete mode 100644 unittests/DebugInfo/CodeView/ErrorChecking.h delete mode 100644 unittests/DebugInfo/PDB/ErrorChecking.h diff --git a/include/llvm/Testing/Support/Error.h b/include/llvm/Testing/Support/Error.h new file mode 100644 index 00000000000..d5275290159 --- /dev/null +++ b/include/llvm/Testing/Support/Error.h @@ -0,0 +1,69 @@ +//===- llvm/Testing/Support/Error.h ---------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_TESTING_SUPPORT_ERROR_H +#define LLVM_TESTING_SUPPORT_ERROR_H + +#include "llvm/ADT/Optional.h" +#include "llvm/Support/Error.h" +#include "llvm/Testing/Support/SupportHelpers.h" + +#include "gmock/gmock.h" +#include + +namespace llvm { +namespace detail { +ErrorHolder TakeError(Error Err); + +template ExpectedHolder TakeExpected(Expected &Exp) { + llvm::detail::ExpectedHolder Result; + auto &EH = static_cast(Result); + EH = TakeError(Exp.takeError()); + if (Result.Success) + Result.Value = &(*Exp); + return Result; +} + +template ExpectedHolder TakeExpected(const Expected &Exp) { + return TakeExpected(const_cast &>(Exp)); +} +} // namespace detail + +#define EXPECT_THAT_ERROR(Err, Matcher) \ + EXPECT_THAT(llvm::detail::TakeError(Err), Matcher) +#define ASSERT_THAT_ERROR(Err, Matcher) \ + ASSERT_THAT(llvm::detail::TakeError(Err), Matcher) + +#define EXPECT_THAT_EXPECTED(Err, Matcher) \ + EXPECT_THAT(llvm::detail::TakeExpected(Err), Matcher) +#define ASSERT_THAT_EXPECTED(Err, Matcher) \ + ASSERT_THAT(llvm::detail::TakeExpected(Err), Matcher) + +MATCHER(Succeeded, "") { return arg.Success; } +MATCHER(Failed, "") { return !arg.Success; } + +MATCHER_P(HasValue, value, + "succeeded with value " + testing::PrintToString(value)) { + if (!arg.Success) { + *result_listener << "operation failed"; + return false; + } + + assert(arg.Value.hasValue()); + if (**arg.Value != value) { + *result_listener << "but \"" + testing::PrintToString(**arg.Value) + + "\" != " + testing::PrintToString(value); + return false; + } + + return true; +} +} // namespace llvm + +#endif diff --git a/include/llvm/Testing/Support/SupportHelpers.h b/include/llvm/Testing/Support/SupportHelpers.h new file mode 100644 index 00000000000..50749ae7db0 --- /dev/null +++ b/include/llvm/Testing/Support/SupportHelpers.h @@ -0,0 +1,46 @@ +//===- Testing/Support/SupportHelpers.h -----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_TESTING_SUPPORT_SUPPORTHELPERS_H +#define LLVM_TESTING_SUPPORT_SUPPORTHELPERS_H + +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/Error.h" + +namespace llvm { +namespace detail { +struct ErrorHolder { + bool Success; + std::string Message; +}; + +template struct ExpectedHolder : public ErrorHolder { + Optional Value; +}; + +inline void PrintTo(const ErrorHolder &Err, std::ostream *Out) { + *Out << (Err.Success ? "succeeded" : "failed"); + if (!Err.Success) { + *Out << " (" << StringRef(Err.Message).trim().str() << ")"; + } +} + +template +void PrintTo(const ExpectedHolder &Item, std::ostream *Out) { + if (Item.Success) { + *Out << "succeeded with value \"" << testing::PrintToString(**Item.Value) + << "\""; + } else { + PrintTo(static_cast(Item), Out); + } +} +} // namespace detail +} // namespace llvm + +#endif diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index f7c09be15fb..946067e6358 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -24,3 +24,4 @@ add_subdirectory(Fuzzer) add_subdirectory(Passes) add_subdirectory(ToolDrivers) add_subdirectory(XRay) +add_subdirectory(Testing) diff --git a/lib/LLVMBuild.txt b/lib/LLVMBuild.txt index 9e586465025..1d22c2a11f1 100644 --- a/lib/LLVMBuild.txt +++ b/lib/LLVMBuild.txt @@ -39,6 +39,7 @@ subdirectories = Support TableGen Target + Testing ToolDrivers Transforms diff --git a/lib/Testing/CMakeLists.txt b/lib/Testing/CMakeLists.txt new file mode 100644 index 00000000000..fc23e64eeb7 --- /dev/null +++ b/lib/Testing/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(Support) diff --git a/lib/Testing/LLVMBuild.txt b/lib/Testing/LLVMBuild.txt new file mode 100644 index 00000000000..cdf83736298 --- /dev/null +++ b/lib/Testing/LLVMBuild.txt @@ -0,0 +1,19 @@ +;===- ./lib/Testing/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 = Support diff --git a/lib/Testing/Support/CMakeLists.txt b/lib/Testing/Support/CMakeLists.txt new file mode 100644 index 00000000000..fa8dfe59c8b --- /dev/null +++ b/lib/Testing/Support/CMakeLists.txt @@ -0,0 +1,12 @@ +add_llvm_library(LLVMTestingSupport + Error.cpp + + BUILDTREE_ONLY + + ADDITIONAL_HEADER_DIRS + ${LLVM_MAIN_INCLUDE_DIR}/llvm/Testing/Support + ) + +include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include) +include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googlemock/include) +target_link_libraries(LLVMTestingSupport PRIVATE gtest) \ No newline at end of file diff --git a/lib/Testing/Support/Error.cpp b/lib/Testing/Support/Error.cpp new file mode 100644 index 00000000000..ce0da44da40 --- /dev/null +++ b/lib/Testing/Support/Error.cpp @@ -0,0 +1,22 @@ +//===- llvm/Testing/Support/Error.cpp -------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Testing/Support/Error.h" + +#include "llvm/ADT/StringRef.h" + +using namespace llvm; + +llvm::detail::ErrorHolder llvm::detail::TakeError(llvm::Error Err) { + bool Succeeded = !static_cast(Err); + std::string Message; + if (!Succeeded) + Message = toString(std::move(Err)); + return {Succeeded, Message}; +} diff --git a/lib/Testing/Support/LLVMBuild.txt b/lib/Testing/Support/LLVMBuild.txt new file mode 100644 index 00000000000..40853e8172d --- /dev/null +++ b/lib/Testing/Support/LLVMBuild.txt @@ -0,0 +1,22 @@ +;===- ./Testing/Support/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 = TestingSupport +parent = Libraries +required_libraries = Support diff --git a/unittests/DebugInfo/CodeView/CMakeLists.txt b/unittests/DebugInfo/CodeView/CMakeLists.txt index aff3b6d09aa..800f482d668 100644 --- a/unittests/DebugInfo/CodeView/CMakeLists.txt +++ b/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/unittests/DebugInfo/CodeView/ErrorChecking.h b/unittests/DebugInfo/CodeView/ErrorChecking.h deleted file mode 100644 index 4ca74c487b3..00000000000 --- a/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(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - -#define EXPECT_ERROR(Err) \ - { \ - auto E = Err; \ - EXPECT_TRUE(static_cast(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - -#define ASSERT_EXPECTED(Exp) \ - { \ - auto E = Exp.takeError(); \ - bool Success = static_cast(E); \ - if (!Success) \ - consumeError(std::move(E)); \ - ASSERT_FALSE(Success); \ - } - -#define EXPECT_EXPECTED(Exp) \ - { \ - auto E = Exp.takeError(); \ - EXPECT_FALSE(static_cast(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(E)); \ - if (E) { \ - consumeError(std::move(E)); \ - return; \ - } \ - EXPECT_EQ(Val, *Result); \ - } - -#define EXPECT_UNEXPECTED(Exp) \ - { \ - auto E = Exp.takeError(); \ - EXPECT_TRUE(static_cast(E)); \ - if (E) { \ - consumeError(std::move(E)); \ - return; \ - } \ - } - -#endif diff --git a/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp b/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp index 0ca24c716d1..4fa172a37ef 100644 --- a/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp +++ b/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 @@ TEST_F(RandomAccessVisitorTest, MultipleVisits) { 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 @@ TEST_F(RandomAccessVisitorTest, DescendingWithinChunk) { 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 @@ TEST_F(RandomAccessVisitorTest, AscendingWithinChunk) { 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 @@ TEST_F(RandomAccessVisitorTest, StopPrematurelyInChunk) { 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 @@ TEST_F(RandomAccessVisitorTest, InnerChunk) { 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/unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp b/unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp index 4eca7777a1e..99c84906be9 100644 --- a/unittests/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp +++ b/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/unittests/DebugInfo/PDB/CMakeLists.txt b/unittests/DebugInfo/PDB/CMakeLists.txt index cbbbd817748..ce6dadfbcdb 100644 --- a/unittests/DebugInfo/PDB/CMakeLists.txt +++ b/unittests/DebugInfo/PDB/CMakeLists.txt @@ -2,6 +2,7 @@ set(LLVM_LINK_COMPONENTS DebugInfoCodeView DebugInfoMSF DebugInfoPDB + TestingSupport ) set(DebugInfoPDBSources diff --git a/unittests/DebugInfo/PDB/ErrorChecking.h b/unittests/DebugInfo/PDB/ErrorChecking.h deleted file mode 100644 index f284bfd8bb7..00000000000 --- a/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(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - -#define EXPECT_ERROR(Err) \ - { \ - auto E = Err; \ - EXPECT_TRUE(static_cast(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - -#define EXPECT_EXPECTED(Exp) \ - { \ - auto E = Exp.takeError(); \ - EXPECT_FALSE(static_cast(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(E)); \ - if (E) { \ - consumeError(std::move(E)); \ - return; \ - } \ - EXPECT_EQ(Val, *Result); \ - } - -#define EXPECT_UNEXPECTED(Exp) \ - { \ - auto E = Exp.takeError(); \ - EXPECT_TRUE(static_cast(E)); \ - if (E) { \ - consumeError(std::move(E)); \ - return; \ - } \ - } - -#endif diff --git a/unittests/DebugInfo/PDB/HashTableTest.cpp b/unittests/DebugInfo/PDB/HashTableTest.cpp index 94c9ee86c4a..f1968e55e86 100644 --- a/unittests/DebugInfo/PDB/HashTableTest.cpp +++ b/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 @@ -150,13 +150,13 @@ TEST(HashTableTest, Serialization) { std::vector 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/unittests/DebugInfo/PDB/MSFBuilderTest.cpp b/unittests/DebugInfo/PDB/MSFBuilderTest.cpp index 5f2f0c271e9..23a15d14f75 100644 --- a/unittests/DebugInfo/PDB/MSFBuilderTest.cpp +++ b/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 @@ TEST_F(MSFBuilderTest, ValidateSuperBlockAccept) { 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 @@ TEST_F(MSFBuilderTest, ValidateSuperBlockReject) { // 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 @@ TEST_F(MSFBuilderTest, TestUsedBlocksMarkedAsUsed) { // 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 @@ TEST_F(MSFBuilderTest, TestAddStreamNoDirectoryBlockIncrease) { // 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 @@ TEST_F(MSFBuilderTest, TestAddStreamWithDirectoryBlockIncrease) { // 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_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()); @@ -178,15 +179,15 @@ TEST_F(MSFBuilderTest, TestGrowStreamWithBlockIncrease) { // 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 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 NewStreamBlocks = Msf.getStreamBlocks(0); EXPECT_EQ(2U, NewStreamBlocks.size()); @@ -199,15 +200,15 @@ 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 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 NewStreamBlocks = Msf.getStreamBlocks(0); EXPECT_EQ(1U, NewStreamBlocks.size()); @@ -220,15 +221,15 @@ TEST_F(MSFBuilderTest, TestShrinkStreamWithBlockDecrease) { // 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 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 NewStreamBlocks = Msf.getStreamBlocks(0); EXPECT_EQ(1U, NewStreamBlocks.size()); @@ -240,20 +241,20 @@ 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 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 @@ TEST_F(MSFBuilderTest, TestBlockCountsWhenAddingStreams) { 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_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); @@ -305,15 +306,15 @@ TEST_F(MSFBuilderTest, BuildMsfLayout) { TEST_F(MSFBuilderTest, UseDirectoryBlockHint) { Expected 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, UseDirectoryBlockHint) { TEST_F(MSFBuilderTest, DirectoryBlockHintInsufficient) { Expected 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, DirectoryBlockHintInsufficient) { TEST_F(MSFBuilderTest, DirectoryBlockHintOverestimated) { Expected 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/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp b/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp index 789fe515b01..a9a1ee4d65b 100644 --- a/unittests/DebugInfo/PDB/MappedBlockStreamTest.cpp +++ b/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 @@ -95,11 +95,11 @@ TEST(MappedBlockStreamTest, ReadBeyondEndOfStreamRef) { BinaryStreamReader R(*S); BinaryStreamRef SR; - EXPECT_NO_ERROR(R.readStreamRef(SR, 0U)); + EXPECT_THAT_ERROR(R.readStreamRef(SR, 0U), Succeeded()); ArrayRef 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 @@ TEST(MappedBlockStreamTest, ReadOntoNonEmptyBuffer) { 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 @@ TEST(MappedBlockStreamTest, ZeroCopyReadContiguousBreak) { 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 @@ TEST(MappedBlockStreamTest, CopyReadNonContiguousBreak) { 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 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNoBreak) { 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 @@ TEST(MappedBlockStreamTest, InvalidReadSizeContiguousBreak) { 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 @@ TEST(MappedBlockStreamTest, InvalidReadSizeNonContiguousBreak) { 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 @@ TEST(MappedBlockStreamTest, ZeroCopyReadNoBreak) { 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 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingRead) { 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 @@ TEST(MappedBlockStreamTest, UnalignedOverlappingReadFail) { 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 @@ TEST(MappedBlockStreamTest, WriteBeyondEndOfStream) { F, F.Allocator); ArrayRef Buffer; - EXPECT_ERROR(S->writeBytes(0, ArrayRef(LargeBuffer))); - EXPECT_NO_ERROR(S->writeBytes(0, ArrayRef(SmallBuffer))); - EXPECT_NO_ERROR(S->writeBytes(7, ArrayRef(SmallBuffer))); - EXPECT_ERROR(S->writeBytes(8, ArrayRef(SmallBuffer))); + EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef(LargeBuffer)), Failed()); + EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef(SmallBuffer)), + Succeeded()); + EXPECT_THAT_ERROR(S->writeBytes(7, ArrayRef(SmallBuffer)), + Succeeded()); + EXPECT_THAT_ERROR(S->writeBytes(8, ArrayRef(SmallBuffer)), Failed()); } TEST(MappedBlockStreamTest, TestWriteBytesNoBreakBoundary) { @@ -270,25 +272,25 @@ TEST(MappedBlockStreamTest, TestWriteBytesNoBreakBoundary) { F, F.Allocator); ArrayRef Buffer; - EXPECT_NO_ERROR(S->readBytes(0, 1, Buffer)); + EXPECT_THAT_ERROR(S->readBytes(0, 1, Buffer), Succeeded()); EXPECT_EQ(Buffer, ArrayRef('A')); - EXPECT_NO_ERROR(S->readBytes(9, 1, Buffer)); + EXPECT_THAT_ERROR(S->readBytes(9, 1, Buffer), Succeeded()); EXPECT_EQ(Buffer, ArrayRef('J')); - EXPECT_NO_ERROR(S->writeBytes(0, ArrayRef('J'))); - EXPECT_NO_ERROR(S->writeBytes(9, ArrayRef('A'))); + EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef('J')), Succeeded()); + EXPECT_THAT_ERROR(S->writeBytes(9, ArrayRef('A')), Succeeded()); - EXPECT_NO_ERROR(S->readBytes(0, 1, Buffer)); + EXPECT_THAT_ERROR(S->readBytes(0, 1, Buffer), Succeeded()); EXPECT_EQ(Buffer, ArrayRef('J')); - EXPECT_NO_ERROR(S->readBytes(9, 1, Buffer)); + EXPECT_THAT_ERROR(S->readBytes(9, 1, Buffer), Succeeded()); EXPECT_EQ(Buffer, ArrayRef('A')); - EXPECT_NO_ERROR(S->writeBytes(0, ArrayRef('A'))); - EXPECT_NO_ERROR(S->writeBytes(9, ArrayRef('J'))); + EXPECT_THAT_ERROR(S->writeBytes(0, ArrayRef('A')), Succeeded()); + EXPECT_THAT_ERROR(S->writeBytes(9, ArrayRef('J')), Succeeded()); - EXPECT_NO_ERROR(S->readBytes(0, 1, Buffer)); + EXPECT_THAT_ERROR(S->readBytes(0, 1, Buffer), Succeeded()); EXPECT_EQ(Buffer, ArrayRef('A')); - EXPECT_NO_ERROR(S->readBytes(9, 1, Buffer)); + EXPECT_THAT_ERROR(S->readBytes(9, 1, Buffer), Succeeded()); EXPECT_EQ(Buffer, ArrayRef('J')); } @@ -303,12 +305,12 @@ TEST(MappedBlockStreamTest, TestWriteBytesBreakBoundary) { F, F.Allocator); ArrayRef 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(Data), ArrayRef(Expected)); - EXPECT_NO_ERROR(S->readBytes(0, 8, Buffer)); + EXPECT_THAT_ERROR(S->readBytes(0, 8, Buffer), Succeeded()); EXPECT_EQ(Buffer, ArrayRef(TestData)); } @@ -340,8 +342,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { 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({0, 0x7A, 0xEC, 0, 0, 0, 0, 0, 0, 0}), DataBytes); @@ -349,8 +351,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { 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({0x17, 0x5C, 0x50, 0, 0, 0, 0x35, 0, 0, 0}), DataBytes); @@ -358,8 +360,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { 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({0x2C, 0x60, 0x4A, 0, 0, 0, 0, 0, 0, 0}), DataBytes); @@ -367,8 +369,8 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { 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({'r', 'e', 'Z', ' ', 'S', 't', 'o', 'r', 0, 0}), @@ -377,8 +379,9 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { 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({'x', 'i', 'F', 'd', ' ', 'S', 'e', 't', 0, 'r'}), @@ -387,8 +390,9 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { 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({0, 0x32, 0x31, 0, 0, 0, 0, 0, 0, 0}), DataBytes); @@ -396,8 +400,9 @@ TEST(MappedBlockStreamTest, TestWriteThenRead) { 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 @@ TEST(MappedBlockStreamTest, TestWriteContiguousStreamRef) { // 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( {'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( {'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 @@ TEST(MappedBlockStreamTest, TestWriteDiscontiguousStreamRef) { // 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( {'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( {'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 @@ TEST(MappedBlockStreamTest, DataLivesAfterStreamDestruction) { 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/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp b/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp index 249bc4a03b8..0efc2c6411b 100644 --- a/unittests/DebugInfo/PDB/StringTableBuilderTest.cpp +++ b/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 @@ TEST_F(StringTableBuilderTest, Simple) { std::vector 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/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp b/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp index 1a30dad7b34..d09b9130ee2 100644 --- a/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp +++ b/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 @@ TEST_F(TypeServerHandlerTest, VisitRecordNoTypeServer) { 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 @@ TEST_F(TypeServerHandlerTest, VisitRecordWithTypeServerOnce) { 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 @@ TEST_F(TypeServerHandlerTest, VisitRecordWithTypeServerAlways) { 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); } diff --git a/unittests/Support/BinaryStreamTest.cpp b/unittests/Support/BinaryStreamTest.cpp index 795c18902a9..e257583e4b1 100644 --- a/unittests/Support/BinaryStreamTest.cpp +++ b/unittests/Support/BinaryStreamTest.cpp @@ -13,6 +13,8 @@ #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 @@ -21,30 +23,6 @@ using namespace llvm; using namespace llvm::support; -#define EXPECT_NO_ERROR(Err) \ - { \ - auto E = Err; \ - EXPECT_FALSE(static_cast(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - -#define ASSERT_NO_ERROR(Err) \ - { \ - auto E = Err; \ - ASSERT_FALSE(static_cast(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - -#define EXPECT_ERROR(Err) \ - { \ - auto E = Err; \ - EXPECT_TRUE(static_cast(E)); \ - if (E) \ - consumeError(std::move(E)); \ - } - namespace { class BrokenStream : public WritableBinaryStream { @@ -227,13 +205,13 @@ TEST_F(BinaryStreamTest, BinaryByteStreamBounds) { // 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()); } } @@ -247,31 +225,31 @@ TEST_F(BinaryStreamTest, StreamRefBounds) { // 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 @@ -280,11 +258,11 @@ TEST_F(BinaryStreamTest, StreamRefBounds) { // 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); } } @@ -298,27 +276,33 @@ TEST_F(BinaryStreamTest, DropOperations) { 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); } @@ -341,22 +325,24 @@ TEST_F(BinaryStreamTest, MutableBinaryByteStreamBounds) { // Read everything from Offset until the end of the input data. ArrayRef 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 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 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()); } } @@ -456,7 +442,7 @@ TEST_F(BinaryStreamTest, StreamReaderBounds) { 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); @@ -465,8 +451,8 @@ TEST_F(BinaryStreamTest, StreamReaderBounds) { 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()); } } @@ -484,11 +470,11 @@ TEST_F(BinaryStreamTest, StreamReaderIntegers) { 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; @@ -498,11 +484,11 @@ TEST_F(BinaryStreamTest, StreamReaderIntegers) { // 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); @@ -523,13 +509,13 @@ TEST_F(BinaryStreamTest, StreamReaderIntegerArray) { for (auto &Stream : Streams) { BinaryStreamReader Reader(*Stream.Input); ArrayRef 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 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(FixedIntsRef.begin(), FixedIntsRef.end())); } @@ -545,7 +531,7 @@ TEST_F(BinaryStreamTest, StreamReaderEnum) { 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); @@ -554,7 +540,7 @@ TEST_F(BinaryStreamTest, StreamReaderEnum) { 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()); @@ -587,9 +573,9 @@ TEST_F(BinaryStreamTest, StreamReaderObject) { 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); @@ -610,10 +596,10 @@ TEST_F(BinaryStreamTest, StreamReaderStrings) { 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); @@ -623,14 +609,14 @@ TEST_F(BinaryStreamTest, StreamReaderStrings) { 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); @@ -648,16 +634,16 @@ TEST_F(BinaryStreamTest, StreamWriterBounds) { // 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()); } } @@ -676,11 +662,12 @@ TEST_F(BinaryStreamTest, StreamWriterIntegerArrays) { ArrayRef Ints; ArrayRef 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); } @@ -698,12 +685,12 @@ TEST_F(BinaryStreamTest, StringWriterStrings) { 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 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)); @@ -748,7 +735,7 @@ TEST_F(BinaryStreamTest, BinaryItemStream) { MutableArrayRef 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)); } @@ -758,7 +745,7 @@ TEST_F(BinaryStreamTest, BinaryItemStream) { 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); diff --git a/unittests/Support/CMakeLists.txt b/unittests/Support/CMakeLists.txt index 098dba83197..348ffba95f2 100644 --- a/unittests/Support/CMakeLists.txt +++ b/unittests/Support/CMakeLists.txt @@ -1,5 +1,6 @@ set(LLVM_LINK_COMPONENTS Support + TestingSupport ) add_llvm_unittest(SupportTests