libstdc++-v3/testsuite/20_util/is_invocable/value.cc

   1 // Copyright (C) 2016-2024 Free Software Foundation, Inc.
   2 //
   3 // This file is part of the GNU ISO C++ Library.  This library is free
   4 // software; you can redistribute it and/or modify it under the
   5 // terms of the GNU General Public License as published by the
   6 // Free Software Foundation; either version 3, or (at your option)
   7 // any later version.
   8
   9 // This library is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13
  14 // You should have received a copy of the GNU General Public License along
  15 // with this library; see the file COPYING3.  If not see
  16 // <http://www.gnu.org/licenses/>.
  17
  18 // { dg-do compile { target c++17 } }
  19
  20 #include <type_traits>
  21
  22 #ifndef IS_INVOCABLE_DEFINED
  23 template<typename... T>
  24   constexpr bool is_invocable()
  25   {
  26     constexpr bool result = std::is_invocable_v<T...>;
  27     static_assert(std::is_invocable<T...>::value == result);
  28     return result;
  29   }
  30
  31 template<typename R, typename... T>
  32   constexpr bool is_invocable_r()
  33   {
  34     constexpr bool result = std::is_invocable_r_v<R, T...>;
  35     static_assert(std::is_invocable_r<R, T...>::value == result);
  36     return result;
  37   }
  38 #endif
  39
  40 void test01()
  41 {
  42   using func_type_v0 = void(*)();
  43
  44   static_assert(   is_invocable< func_type_v0 >(),          "");
  45   static_assert(   is_invocable_r<void,  func_type_v0 >(),  "");
  46   static_assert( ! is_invocable_r<void*, func_type_v0 >(),  "");
  47   static_assert( ! is_invocable_r<int,   func_type_v0 >(),  "");
  48
  49   static_assert( ! is_invocable< func_type_v0, int >(),       "");
  50   static_assert( ! is_invocable_r< void,  func_type_v0, int >(), "");
  51   static_assert( ! is_invocable_r< void*, func_type_v0, int >(), "");
  52   static_assert( ! is_invocable_r< int,   func_type_v0, int >(), "");
  53
  54   using func_type_i0 = int(*)();
  55
  56   static_assert(   is_invocable< func_type_i0 >(),        "");
  57   static_assert(   is_invocable_r<void, func_type_i0 >(), "");
  58   static_assert(   is_invocable_r<int,  func_type_i0 >(), "");
  59   static_assert( ! is_invocable_r<int&, func_type_i0 >(), "");
  60   static_assert(   is_invocable_r<long, func_type_i0 >(), "");
  61
  62   static_assert( ! is_invocable< func_type_i0, int >(),      "");
  63   static_assert( ! is_invocable_r< void, func_type_i0, int >(), "");
  64   static_assert( ! is_invocable_r< int,  func_type_i0, int >(), "");
  65   static_assert( ! is_invocable_r< int&, func_type_i0, int >(), "");
  66   static_assert( ! is_invocable_r< long, func_type_i0, int >(), "");
  67
  68   using func_type_l0 = int&(*)();
  69
  70   static_assert(   is_invocable< func_type_l0 >(),          "");
  71   static_assert(   is_invocable_r< void,  func_type_l0 >(),   "");
  72   static_assert(   is_invocable_r< int,   func_type_l0 >(),    "");
  73   static_assert(   is_invocable_r< int&,  func_type_l0 >(),   "");
  74   static_assert( ! is_invocable_r< int&&, func_type_l0 >(),  "");
  75   static_assert(   is_invocable_r< long,  func_type_l0 >(),   "");
  76   static_assert( ! is_invocable_r< long&, func_type_l0 >(),  "");
  77
  78   static_assert( ! is_invocable< func_type_l0(int) >(),       "");
  79   static_assert( ! is_invocable_r< void, func_type_l0, int >(),  "");
  80   static_assert( ! is_invocable_r< int,  func_type_l0, int >(),  "");
  81   static_assert( ! is_invocable_r< int&, func_type_l0, int >(),  "");
  82   static_assert( ! is_invocable_r< long, func_type_l0, int >(),  "");
  83
  84   using func_type_ii = int(*)(int);
  85
  86   static_assert( ! is_invocable< func_type_ii >(),        "");
  87   static_assert( ! is_invocable_r< int,  func_type_ii >(), "");
  88   static_assert( ! is_invocable_r< int&, func_type_ii >(), "");
  89   static_assert( ! is_invocable_r< long, func_type_ii >(), "");
  90
  91   static_assert(   is_invocable< func_type_ii, int >(),       "");
  92   static_assert(   is_invocable_r< int,  func_type_ii, int >(),  "");
  93   static_assert( ! is_invocable_r< int&, func_type_ii, int >(),  "");
  94   static_assert(   is_invocable_r< long, func_type_ii, int >(),  "");
  95
  96   using func_type_il = int(*)(int&);
  97
  98   static_assert( ! is_invocable< func_type_il >(),        "");
  99
 100   static_assert( ! is_invocable< func_type_il, int >(),       "");
 101   static_assert( ! is_invocable_r< int,  func_type_il, int >(),  "");
 102   static_assert( ! is_invocable_r< int&, func_type_il, int >(),  "");
 103   static_assert( ! is_invocable_r< long, func_type_il, int >(),  "");
 104
 105   static_assert(   is_invocable< func_type_il, int& >(),              "");
 106   static_assert(   is_invocable_r< int,  func_type_il, int& >(), "");
 107   static_assert( ! is_invocable_r< int&, func_type_il, int& >(), "");
 108   static_assert(   is_invocable_r< long, func_type_il, int& >(), "");
 109
 110   using func_type_ir = int(*)(int&&);
 111
 112   static_assert( ! is_invocable< func_type_ir >(),        "");
 113
 114   static_assert(   is_invocable< func_type_ir, int >(),       "");
 115   static_assert(   is_invocable_r< int,  func_type_ir, int >(),  "");
 116   static_assert( ! is_invocable_r< int&, func_type_ir, int >(),  "");
 117   static_assert(   is_invocable_r< long, func_type_ir, int >(),  "");
 118
 119   static_assert( ! is_invocable< func_type_ir, int& >(),              "");
 120   static_assert( ! is_invocable_r< int,  func_type_ir, int& >(), "");
 121   static_assert( ! is_invocable_r< int&, func_type_ir, int& >(), "");
 122   static_assert( ! is_invocable_r< long, func_type_ir, int& >(), "");
 123
 124   struct X { };
 125
 126   using mem_type_i = int X::*;
 127
 128   static_assert( ! is_invocable< mem_type_i >(),          "");
 129
 130   static_assert( ! is_invocable< mem_type_i, int >(),       "");
 131   static_assert( ! is_invocable_r< int,  mem_type_i, int >(),  "");
 132   static_assert( ! is_invocable_r< int&, mem_type_i, int >(),  "");
 133   static_assert( ! is_invocable_r< long, mem_type_i, int >(),  "");
 134
 135   static_assert( ! is_invocable< mem_type_i, int& >(),      "");
 136   static_assert( ! is_invocable_r< int,  mem_type_i, int& >(), "");
 137   static_assert( ! is_invocable_r< int&, mem_type_i, int& >(), "");
 138   static_assert( ! is_invocable_r< long, mem_type_i, int& >(), "");
 139
 140   static_assert(   is_invocable< mem_type_i, X& >(),      "");
 141   static_assert(   is_invocable_r< int,  mem_type_i, X& >(), "");
 142   static_assert(   is_invocable_r< int&, mem_type_i, X& >(), "");
 143   static_assert(   is_invocable_r< long, mem_type_i, X& >(), "");
 144
 145   using memfun_type_i = int (X::*)();
 146
 147   static_assert( ! is_invocable< memfun_type_i >(),      "");
 148
 149   static_assert( ! is_invocable< memfun_type_i, int >(),         "");
 150
 151   static_assert( ! is_invocable< memfun_type_i, int& >(), "");
 152
 153   static_assert(   is_invocable< memfun_type_i, X& >(),       "");
 154   static_assert(   is_invocable_r< int,  memfun_type_i, X& >(),  "");
 155   static_assert( ! is_invocable_r< int&, memfun_type_i, X& >(),  "");
 156   static_assert(   is_invocable_r< long, memfun_type_i, X& >(),  "");
 157   static_assert(   is_invocable< memfun_type_i, X* >(),       "");
 158
 159   static_assert( ! is_invocable< memfun_type_i, const X& >(),         "");
 160   static_assert( ! is_invocable_r< int,  memfun_type_i, const X& >(),  "");
 161   static_assert( ! is_invocable< memfun_type_i, X&, int >(), "");
 162
 163   using memfun_type_iic = int& (X::*)(int&) const;
 164
 165   static_assert( ! is_invocable< memfun_type_iic >(),                 "");
 166   static_assert( ! is_invocable< memfun_type_iic, int  >(),           "");
 167   static_assert( ! is_invocable< memfun_type_iic, int& >(),           "");
 168   static_assert( ! is_invocable< memfun_type_iic, X&, int >(),        "");
 169   static_assert( ! is_invocable< memfun_type_iic, const X&, int >(),  "");
 170   static_assert( ! is_invocable< memfun_type_iic, const X&, int&, int  >(), "");
 171
 172   static_assert(   is_invocable< memfun_type_iic, const X&, int&  >(),     "");
 173   static_assert(   is_invocable_r< int,  memfun_type_iic, const X&, int& >(), "");
 174   static_assert(   is_invocable_r< int&, memfun_type_iic, const X&, int& >(), "");
 175   static_assert(   is_invocable_r< long, memfun_type_iic, const X&, int& >(), "");
 176   static_assert( ! is_invocable_r< long&, memfun_type_iic, const X&, int& >(),"");
 177   static_assert(   is_invocable< memfun_type_iic, const X*, int&  >(),     "");
 178
 179   struct F {
 180     int& operator()();
 181     long& operator()() const;
 182     short& operator()(int) &&;
 183     char& operator()(int) const&;
 184   private:
 185     void operator()(int, int);
 186   };
 187   using CF = const F;
 188
 189   static_assert(   is_invocable_r< int&,   F        >(), "");
 190   static_assert(   is_invocable_r< int&,   F&       >(), "");
 191   static_assert(   is_invocable_r< long&,  CF       >(), "");
 192   static_assert(   is_invocable_r< long&,  CF&      >(), "");
 193   static_assert(   is_invocable_r< short&, F,   int >(), "");
 194   static_assert(   is_invocable_r< char&,  F&,  int >(), "");
 195   static_assert(   is_invocable_r< char&,  CF,  int >(), "");
 196   static_assert(   is_invocable_r< char&,  CF&, int >(), "");
 197
 198   static_assert( ! is_invocable< F, int, int >(), "");
 199 }