libcxx/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03, c++11, c++14
  10
  11 // type_traits
  12
  13 // is_nothrow_invocable
  14
  15 #include <type_traits>
  16 #include <functional>
  17 #include <vector>
  18
  19 #include "test_macros.h"
  20
  21 struct Tag {};
  22
  23 struct Implicit {
  24   Implicit(int) noexcept {}
  25 };
  26
  27 struct ThrowsImplicit {
  28   ThrowsImplicit(int) {}
  29 };
  30
  31 struct Explicit {
  32   explicit Explicit(int) noexcept {}
  33 };
  34
  35 template <bool IsNoexcept, class Ret, class... Args>
  36 struct CallObject {
  37   Ret operator()(Args&&...) const noexcept(IsNoexcept);
  38 };
  39
  40 struct Sink {
  41   template <class... Args>
  42   void operator()(Args&&...) const noexcept {}
  43 };
  44
  45 template <class Fn, class... Args>
  46 constexpr bool throws_invocable() {
  47   return std::is_invocable<Fn, Args...>::value &&
  48          !std::is_nothrow_invocable<Fn, Args...>::value;
  49 }
  50
  51 template <class Ret, class Fn, class... Args>
  52 constexpr bool throws_invocable_r() {
  53   return std::is_invocable_r<Ret, Fn, Args...>::value &&
  54          !std::is_nothrow_invocable_r<Ret, Fn, Args...>::value;
  55 }
  56
  57 void test_noexcept_function_pointers() {
  58   struct Dummy {
  59     void foo() noexcept {}
  60     static void bar() noexcept {}
  61   };
  62   // Check that PMF's and function pointers actually work and that
  63   // is_nothrow_invocable returns true for noexcept PMF's and function
  64   // pointers.
  65   static_assert(std::is_nothrow_invocable<decltype(&Dummy::foo), Dummy&>::value, "");
  66   static_assert(std::is_nothrow_invocable<decltype(&Dummy::bar)>::value, "");
  67 }
  68
  69 int main(int, char**) {
  70   using AbominableFunc = void(...) const noexcept;
  71   //  Non-callable things
  72   {
  73     static_assert(!std::is_nothrow_invocable<void>::value, "");
  74     static_assert(!std::is_nothrow_invocable<const void>::value, "");
  75     static_assert(!std::is_nothrow_invocable<volatile void>::value, "");
  76     static_assert(!std::is_nothrow_invocable<const volatile void>::value, "");
  77     static_assert(!std::is_nothrow_invocable<std::nullptr_t>::value, "");
  78     static_assert(!std::is_nothrow_invocable<int>::value, "");
  79     static_assert(!std::is_nothrow_invocable<double>::value, "");
  80
  81     static_assert(!std::is_nothrow_invocable<int[]>::value, "");
  82     static_assert(!std::is_nothrow_invocable<int[3]>::value, "");
  83
  84     static_assert(!std::is_nothrow_invocable<int*>::value, "");
  85     static_assert(!std::is_nothrow_invocable<const int*>::value, "");
  86     static_assert(!std::is_nothrow_invocable<int const*>::value, "");
  87
  88     static_assert(!std::is_nothrow_invocable<int&>::value, "");
  89     static_assert(!std::is_nothrow_invocable<const int&>::value, "");
  90     static_assert(!std::is_nothrow_invocable<int&&>::value, "");
  91
  92     static_assert(!std::is_nothrow_invocable<int, std::vector<int> >::value,
  93                   "");
  94     static_assert(!std::is_nothrow_invocable<int, std::vector<int*> >::value,
  95                   "");
  96     static_assert(!std::is_nothrow_invocable<int, std::vector<int**> >::value,
  97                   "");
  98
  99     static_assert(!std::is_nothrow_invocable<AbominableFunc>::value, "");
 100
 101     //  with parameters
 102     static_assert(!std::is_nothrow_invocable<int, int>::value, "");
 103     static_assert(!std::is_nothrow_invocable<int, double, float>::value, "");
 104     static_assert(!std::is_nothrow_invocable<int, char, float, double>::value,
 105                   "");
 106     static_assert(!std::is_nothrow_invocable<Sink, AbominableFunc>::value, "");
 107     static_assert(!std::is_nothrow_invocable<Sink, void>::value, "");
 108     static_assert(!std::is_nothrow_invocable<Sink, const volatile void>::value,
 109                   "");
 110
 111     static_assert(!std::is_nothrow_invocable_r<int, void>::value, "");
 112     static_assert(!std::is_nothrow_invocable_r<int, const void>::value, "");
 113     static_assert(!std::is_nothrow_invocable_r<int, volatile void>::value, "");
 114     static_assert(!std::is_nothrow_invocable_r<int, const volatile void>::value,
 115                   "");
 116     static_assert(!std::is_nothrow_invocable_r<int, std::nullptr_t>::value, "");
 117     static_assert(!std::is_nothrow_invocable_r<int, int>::value, "");
 118     static_assert(!std::is_nothrow_invocable_r<int, double>::value, "");
 119
 120     static_assert(!std::is_nothrow_invocable_r<int, int[]>::value, "");
 121     static_assert(!std::is_nothrow_invocable_r<int, int[3]>::value, "");
 122
 123     static_assert(!std::is_nothrow_invocable_r<int, int*>::value, "");
 124     static_assert(!std::is_nothrow_invocable_r<int, const int*>::value, "");
 125     static_assert(!std::is_nothrow_invocable_r<int, int const*>::value, "");
 126
 127     static_assert(!std::is_nothrow_invocable_r<int, int&>::value, "");
 128     static_assert(!std::is_nothrow_invocable_r<int, const int&>::value, "");
 129     static_assert(!std::is_nothrow_invocable_r<int, int&&>::value, "");
 130
 131     static_assert(!std::is_nothrow_invocable_r<int, std::vector<int> >::value,
 132                   "");
 133     static_assert(!std::is_nothrow_invocable_r<int, std::vector<int*> >::value,
 134                   "");
 135     static_assert(!std::is_nothrow_invocable_r<int, std::vector<int**> >::value,
 136                   "");
 137     static_assert(!std::is_nothrow_invocable_r<void, AbominableFunc>::value,
 138                   "");
 139
 140     //  with parameters
 141     static_assert(!std::is_nothrow_invocable_r<int, int, int>::value, "");
 142     static_assert(!std::is_nothrow_invocable_r<int, int, double, float>::value,
 143                   "");
 144     static_assert(
 145         !std::is_nothrow_invocable_r<int, int, char, float, double>::value, "");
 146     static_assert(
 147         !std::is_nothrow_invocable_r<void, Sink, AbominableFunc>::value, "");
 148     static_assert(!std::is_nothrow_invocable_r<void, Sink, void>::value, "");
 149     static_assert(
 150         !std::is_nothrow_invocable_r<void, Sink, const volatile void>::value,
 151         "");
 152   }
 153
 154   {
 155     // Check that the conversion to the return type is properly checked
 156     using Fn = CallObject<true, int>;
 157     static_assert(std::is_nothrow_invocable_r<Implicit, Fn>::value, "");
 158     static_assert(std::is_nothrow_invocable_r<double, Fn>::value, "");
 159     static_assert(std::is_nothrow_invocable_r<const volatile void, Fn>::value,
 160                   "");
 161     static_assert(throws_invocable_r<ThrowsImplicit, Fn>(), "");
 162     static_assert(!std::is_nothrow_invocable<Fn(), Explicit>(), "");
 163   }
 164   {
 165     // Check that the conversion to the parameters is properly checked
 166     using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
 167     static_assert(
 168         std::is_nothrow_invocable<Fn, Implicit&, ThrowsImplicit&>::value, "");
 169     static_assert(std::is_nothrow_invocable<Fn, int, ThrowsImplicit&>::value,
 170                   "");
 171     static_assert(throws_invocable<Fn, int, int>(), "");
 172     static_assert(!std::is_nothrow_invocable<Fn>::value, "");
 173   }
 174   {
 175     // Check that the noexcept-ness of function objects is checked.
 176     using Fn = CallObject<true, void>;
 177     using Fn2 = CallObject<false, void>;
 178     static_assert(std::is_nothrow_invocable<Fn>::value, "");
 179     static_assert(throws_invocable<Fn2>(), "");
 180   }
 181   {
 182     // Check that PMD derefs are noexcept
 183     using Fn = int(Tag::*);
 184     static_assert(std::is_nothrow_invocable<Fn, Tag&>::value, "");
 185     static_assert(std::is_nothrow_invocable_r<Implicit, Fn, Tag&>::value, "");
 186     static_assert(throws_invocable_r<ThrowsImplicit, Fn, Tag&>(), "");
 187   }
 188   {
 189     // Check that it's fine if the result type is non-moveable.
 190     struct CantMove {
 191       CantMove() = default;
 192       CantMove(CantMove&&) = delete;
 193     };
 194
 195     static_assert(!std::is_move_constructible_v<CantMove>);
 196     static_assert(!std::is_copy_constructible_v<CantMove>);
 197
 198     using Fn = CantMove() noexcept;
 199
 200     static_assert(std::is_nothrow_invocable_r<CantMove, Fn>::value);
 201     static_assert(!std::is_nothrow_invocable_r<CantMove, Fn, int>::value);
 202
 203     static_assert(std::is_nothrow_invocable_r_v<CantMove, Fn>);
 204     static_assert(!std::is_nothrow_invocable_r_v<CantMove, Fn, int>);
 205   }
 206   {
 207     // Check for is_nothrow_invocable_v
 208     using Fn = CallObject<true, int>;
 209     static_assert(std::is_nothrow_invocable_v<Fn>, "");
 210     static_assert(!std::is_nothrow_invocable_v<Fn, int>, "");
 211   }
 212   {
 213     // Check for is_nothrow_invocable_r_v
 214     using Fn = CallObject<true, int>;
 215     static_assert(std::is_nothrow_invocable_r_v<void, Fn>, "");
 216     static_assert(!std::is_nothrow_invocable_r_v<int, Fn, int>, "");
 217   }
 218   test_noexcept_function_pointers();
 219
 220   return 0;
 221 }