LCOV - code coverage report
Current view: top level - include/llvm/Testing/Support - Error.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 19 23 82.6 %
Date: 2018-02-19 17:12:42 Functions: 51 98 52.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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"
      15             : #include "llvm/Testing/Support/SupportHelpers.h"
      16             : 
      17             : #include "gmock/gmock.h"
      18             : #include <ostream>
      19             : 
      20             : namespace llvm {
      21             : namespace detail {
      22             : ErrorHolder TakeError(Error Err);
      23             : 
      24          94 : template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &Exp) {
      25         282 :   return {TakeError(Exp.takeError()), Exp};
      26             : }
      27             : 
      28             : template <typename T> ExpectedHolder<T> TakeExpected(Expected<T> &&Exp) {
      29          37 :   return TakeExpected(Exp);
      30             : }
      31             : 
      32             : template <typename T>
      33          26 : class ValueMatchesMono
      34             :     : public testing::MatcherInterface<const ExpectedHolder<T> &> {
      35             : public:
      36          13 :   explicit ValueMatchesMono(const testing::Matcher<T> &Matcher)
      37          13 :       : Matcher(Matcher) {}
      38             : 
      39          13 :   bool MatchAndExplain(const ExpectedHolder<T> &Holder,
      40             :                        testing::MatchResultListener *listener) const override {
      41          13 :     if (!Holder.Success)
      42             :       return false;
      43             : 
      44          11 :     bool result = Matcher.MatchAndExplain(*Holder.Exp, listener);
      45             : 
      46          11 :     if (result)
      47             :       return result;
      48             :     *listener << "(";
      49           2 :     Matcher.DescribeNegationTo(listener->stream());
      50             :     *listener << ")";
      51             :     return result;
      52             :   }
      53             : 
      54           4 :   void DescribeTo(std::ostream *OS) const override {
      55           4 :     *OS << "succeeded with value (";
      56             :     Matcher.DescribeTo(OS);
      57           4 :     *OS << ")";
      58           4 :   }
      59             : 
      60           0 :   void DescribeNegationTo(std::ostream *OS) const override {
      61           0 :     *OS << "did not succeed or value (";
      62             :     Matcher.DescribeNegationTo(OS);
      63           0 :     *OS << ")";
      64           0 :   }
      65             : 
      66             : private:
      67             :   testing::Matcher<T> Matcher;
      68             : };
      69             : 
      70             : template<typename M>
      71             : class ValueMatchesPoly {
      72             : public:
      73             :   explicit ValueMatchesPoly(const M &Matcher) : Matcher(Matcher) {}
      74             : 
      75             :   template <typename T>
      76          13 :   operator testing::Matcher<const ExpectedHolder<T> &>() const {
      77             :     return MakeMatcher(
      78          35 :         new ValueMatchesMono<T>(testing::SafeMatcherCast<T>(Matcher)));
      79             :   }
      80             : 
      81             : private:
      82             :   M Matcher;
      83             : };
      84             : 
      85             : } // namespace detail
      86             : 
      87             : #define EXPECT_THAT_ERROR(Err, Matcher)                                        \
      88             :   EXPECT_THAT(llvm::detail::TakeError(Err), Matcher)
      89             : #define ASSERT_THAT_ERROR(Err, Matcher)                                        \
      90             :   ASSERT_THAT(llvm::detail::TakeError(Err), Matcher)
      91             : 
      92             : #define EXPECT_THAT_EXPECTED(Err, Matcher)                                     \
      93             :   EXPECT_THAT(llvm::detail::TakeExpected(Err), Matcher)
      94             : #define ASSERT_THAT_EXPECTED(Err, Matcher)                                     \
      95             :   ASSERT_THAT(llvm::detail::TakeExpected(Err), Matcher)
      96             : 
      97        2845 : MATCHER(Succeeded, "") { return arg.Success; }
      98         229 : MATCHER(Failed, "") { return !arg.Success; }
      99             : 
     100             : template <typename M>
     101             : detail::ValueMatchesPoly<M> HasValue(M Matcher) {
     102             :   return detail::ValueMatchesPoly<M>(Matcher);
     103             : }
     104             : 
     105             : } // namespace llvm
     106             : 
     107             : #endif

Generated by: LCOV version 1.13