LLVM  7.0.0svn
Error.h
Go to the documentation of this file.
1 //===- llvm/Testing/Support/Error.h ---------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_TESTING_SUPPORT_ERROR_H
11 #define LLVM_TESTING_SUPPORT_ERROR_H
12 
13 #include "llvm/ADT/Optional.h"
14 #include "llvm/Support/Error.h"
16 
17 #include "gmock/gmock.h"
18 #include <ostream>
19 
20 namespace llvm {
21 namespace detail {
22 ErrorHolder TakeError(Error Err);
23 
24 template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &Exp) {
25  return {TakeError(Exp.takeError()), Exp};
26 }
27 
28 template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &&Exp) {
29  return TakeExpected(Exp);
30 }
31 
32 template <typename T>
34  : public testing::MatcherInterface<const ExpectedHolder<T> &> {
35 public:
36  explicit ValueMatchesMono(const testing::Matcher<T> &Matcher)
37  : Matcher(Matcher) {}
38 
39  bool MatchAndExplain(const ExpectedHolder<T> &Holder,
40  testing::MatchResultListener *listener) const override {
41  if (!Holder.Success())
42  return false;
43 
44  bool result = Matcher.MatchAndExplain(*Holder.Exp, listener);
45 
46  if (result)
47  return result;
48  *listener << "(";
49  Matcher.DescribeNegationTo(listener->stream());
50  *listener << ")";
51  return result;
52  }
53 
54  void DescribeTo(std::ostream *OS) const override {
55  *OS << "succeeded with value (";
56  Matcher.DescribeTo(OS);
57  *OS << ")";
58  }
59 
60  void DescribeNegationTo(std::ostream *OS) const override {
61  *OS << "did not succeed or value (";
62  Matcher.DescribeNegationTo(OS);
63  *OS << ")";
64  }
65 
66 private:
67  testing::Matcher<T> Matcher;
68 };
69 
70 template<typename M>
72 public:
73  explicit ValueMatchesPoly(const M &Matcher) : Matcher(Matcher) {}
74 
75  template <typename T>
76  operator testing::Matcher<const ExpectedHolder<T> &>() const {
77  return MakeMatcher(
78  new ValueMatchesMono<T>(testing::SafeMatcherCast<T>(Matcher)));
79  }
80 
81 private:
82  M Matcher;
83 };
84 
85 template <typename InfoT>
86 class ErrorMatchesMono : public testing::MatcherInterface<const ErrorHolder &> {
87 public:
88  explicit ErrorMatchesMono(Optional<testing::Matcher<InfoT &>> Matcher)
89  : Matcher(std::move(Matcher)) {}
90 
91  bool MatchAndExplain(const ErrorHolder &Holder,
92  testing::MatchResultListener *listener) const override {
93  if (Holder.Success())
94  return false;
95 
96  if (Holder.Infos.size() > 1) {
97  *listener << "multiple errors";
98  return false;
99  }
100 
101  auto &Info = *Holder.Infos[0];
102  if (!Info.isA<InfoT>()) {
103  *listener << "Error was not of given type";
104  return false;
105  }
106 
107  if (!Matcher)
108  return true;
109 
110  return Matcher->MatchAndExplain(static_cast<InfoT &>(Info), listener);
111  }
112 
113  void DescribeTo(std::ostream *OS) const override {
114  *OS << "failed with Error of given type";
115  if (Matcher) {
116  *OS << " and the error ";
117  Matcher->DescribeTo(OS);
118  }
119  }
120 
121  void DescribeNegationTo(std::ostream *OS) const override {
122  *OS << "succeeded or did not fail with the error of given type";
123  if (Matcher) {
124  *OS << " or the error ";
125  Matcher->DescribeNegationTo(OS);
126  }
127  }
128 
129 private:
131 };
132 } // namespace detail
133 
134 #define EXPECT_THAT_ERROR(Err, Matcher) \
135  EXPECT_THAT(llvm::detail::TakeError(Err), Matcher)
136 #define ASSERT_THAT_ERROR(Err, Matcher) \
137  ASSERT_THAT(llvm::detail::TakeError(Err), Matcher)
138 
139 #define EXPECT_THAT_EXPECTED(Err, Matcher) \
140  EXPECT_THAT(llvm::detail::TakeExpected(Err), Matcher)
141 #define ASSERT_THAT_EXPECTED(Err, Matcher) \
142  ASSERT_THAT(llvm::detail::TakeExpected(Err), Matcher)
143 
144 MATCHER(Succeeded, "") { return arg.Success(); }
145 MATCHER(Failed, "") { return !arg.Success(); }
146 
147 template <typename InfoT>
148 testing::Matcher<const detail::ErrorHolder &> Failed() {
149  return MakeMatcher(new detail::ErrorMatchesMono<InfoT>(None));
150 }
151 
152 template <typename InfoT, typename M>
153 testing::Matcher<const detail::ErrorHolder &> Failed(M Matcher) {
154  return MakeMatcher(new detail::ErrorMatchesMono<InfoT>(
155  testing::SafeMatcherCast<InfoT &>(Matcher)));
156 }
157 
158 template <typename M>
160  return detail::ValueMatchesPoly<M>(Matcher);
161 }
162 
163 } // namespace llvm
164 
165 #endif
ValueMatchesPoly(const M &Matcher)
Definition: Error.h:73
const NoneType None
Definition: None.h:24
ErrorHolder TakeError(Error Err)
Definition: Error.cpp:16
void DescribeNegationTo(std::ostream *OS) const override
Definition: Error.h:60
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
ExpectedHolder< T > TakeExpected(Expected< T > &Exp)
Definition: Error.h:24
detail::ValueMatchesPoly< M > HasValue(M Matcher)
Definition: Error.h:159
Error takeError()
Take ownership of the stored error.
Definition: Error.h:545
void DescribeNegationTo(std::ostream *OS) const override
Definition: Error.h:121
Definition: BitVector.h:921
void DescribeTo(std::ostream *OS) const override
Definition: Error.h:113
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
std::vector< std::shared_ptr< ErrorInfoBase > > Infos
bool MatchAndExplain(const ErrorHolder &Holder, testing::MatchResultListener *listener) const override
Definition: Error.h:91
void DescribeTo(std::ostream *OS) const override
Definition: Error.h:54
testing::Matcher< const detail::ErrorHolder & > Failed()
Definition: Error.h:148
bool MatchAndExplain(const ExpectedHolder< T > &Holder, testing::MatchResultListener *listener) const override
Definition: Error.h:39
MATCHER(Succeeded, "")
Definition: Error.h:144
ValueMatchesMono(const testing::Matcher< T > &Matcher)
Definition: Error.h:36
ErrorMatchesMono(Optional< testing::Matcher< InfoT &>> Matcher)
Definition: Error.h:88