ceph/src/boost/libs/asio/test/execution/set_error.cpp

   1 //
   2 // set_error.cpp
   3 // ~~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 // Disable autolinking for unit tests.
  12 #if !defined(BOOST_ALL_NO_LIB)
  13 #define BOOST_ALL_NO_LIB 1
  14 #endif // !defined(BOOST_ALL_NO_LIB)
  15
  16 // Test that header file is self-contained.
  17 #include <boost/asio/execution/set_error.hpp>
  18
  19 #include <boost/system/error_code.hpp>
  20 #include "../unit_test.hpp"
  21
  22 namespace exec = boost::asio::execution;
  23
  24 static int call_count = 0;
  25
  26 struct no_set_error
  27 {
  28 };
  29
  30 struct const_member_set_error
  31 {
  32   template <typename E>
  33   void set_error(BOOST_ASIO_MOVE_ARG(E) e) const BOOST_ASIO_NOEXCEPT
  34   {
  35     typename boost::asio::decay<E>::type tmp(BOOST_ASIO_MOVE_CAST(E)(e));
  36     (void)tmp;
  37     ++call_count;
  38   }
  39 };
  40
  41 #if !defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_MEMBER_TRAIT)
  42
  43 namespace boost {
  44 namespace asio {
  45 namespace traits {
  46
  47 template <typename E>
  48 struct set_error_member<const const_member_set_error, E>
  49 {
  50   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
  51   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
  52   typedef void result_type;
  53 };
  54
  55 } // namespace traits
  56 } // namespace asio
  57 } // namespace boost
  58
  59 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_MEMBER_TRAIT)
  60
  61 struct free_set_error_const_receiver
  62 {
  63   template <typename E>
  64   friend void set_error(const free_set_error_const_receiver&,
  65       BOOST_ASIO_MOVE_ARG(E) e) BOOST_ASIO_NOEXCEPT
  66   {
  67     typename boost::asio::decay<E>::type tmp(BOOST_ASIO_MOVE_CAST(E)(e));
  68     (void)tmp;
  69     ++call_count;
  70   }
  71 };
  72
  73 #if !defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_FREE_TRAIT)
  74
  75 namespace boost {
  76 namespace asio {
  77 namespace traits {
  78
  79 template <typename E>
  80 struct set_error_free<const free_set_error_const_receiver, E>
  81 {
  82   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
  83   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
  84   typedef void result_type;
  85 };
  86
  87 } // namespace traits
  88 } // namespace asio
  89 } // namespace boost
  90
  91 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_FREE_TRAIT)
  92
  93 struct non_const_member_set_error
  94 {
  95   template <typename E>
  96   void set_error(BOOST_ASIO_MOVE_ARG(E) e) BOOST_ASIO_NOEXCEPT
  97   {
  98     typename boost::asio::decay<E>::type tmp(BOOST_ASIO_MOVE_CAST(E)(e));
  99     (void)tmp;
 100     ++call_count;
 101   }
 102 };
 103
 104 #if !defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_MEMBER_TRAIT)
 105
 106 namespace boost {
 107 namespace asio {
 108 namespace traits {
 109
 110 template <typename E>
 111 struct set_error_member<non_const_member_set_error, E>
 112 {
 113   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 114   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 115   typedef void result_type;
 116 };
 117
 118 } // namespace traits
 119 } // namespace asio
 120 } // namespace boost
 121
 122 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_MEMBER_TRAIT)
 123
 124 struct free_set_error_non_const_receiver
 125 {
 126   template <typename E>
 127   friend void set_error(free_set_error_non_const_receiver&,
 128       BOOST_ASIO_MOVE_ARG(E) e) BOOST_ASIO_NOEXCEPT
 129   {
 130     typename boost::asio::decay<E>::type tmp(BOOST_ASIO_MOVE_CAST(E)(e));
 131     (void)tmp;
 132     ++call_count;
 133   }
 134 };
 135
 136 #if !defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_FREE_TRAIT)
 137
 138 namespace boost {
 139 namespace asio {
 140 namespace traits {
 141
 142 template <typename E>
 143 struct set_error_free<free_set_error_non_const_receiver, E>
 144 {
 145   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
 146   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 147   typedef void result_type;
 148 };
 149
 150 } // namespace traits
 151 } // namespace asio
 152 } // namespace boost
 153
 154 #endif // !defined(BOOST_ASIO_HAS_DEDUCED_SET_ERROR_FREE_TRAIT)
 155
 156 void test_can_set_error()
 157 {
 158   BOOST_ASIO_CONSTEXPR bool b1 = exec::can_set_error<
 159       no_set_error&, boost::system::error_code>::value;
 160   BOOST_ASIO_CHECK(b1 == false);
 161
 162   BOOST_ASIO_CONSTEXPR bool b2 = exec::can_set_error<
 163       const no_set_error&, boost::system::error_code>::value;
 164   BOOST_ASIO_CHECK(b2 == false);
 165
 166   BOOST_ASIO_CONSTEXPR bool b3 = exec::can_set_error<
 167       const_member_set_error&, boost::system::error_code>::value;
 168   BOOST_ASIO_CHECK(b3 == true);
 169
 170   BOOST_ASIO_CONSTEXPR bool b4 = exec::can_set_error<
 171       const const_member_set_error&, boost::system::error_code>::value;
 172   BOOST_ASIO_CHECK(b4 == true);
 173
 174   BOOST_ASIO_CONSTEXPR bool b5 = exec::can_set_error<
 175       free_set_error_const_receiver&, boost::system::error_code>::value;
 176   BOOST_ASIO_CHECK(b5 == true);
 177
 178   BOOST_ASIO_CONSTEXPR bool b6 = exec::can_set_error<
 179       const free_set_error_const_receiver&, boost::system::error_code>::value;
 180   BOOST_ASIO_CHECK(b6 == true);
 181
 182   BOOST_ASIO_CONSTEXPR bool b7 = exec::can_set_error<
 183       non_const_member_set_error&, boost::system::error_code>::value;
 184   BOOST_ASIO_CHECK(b7 == true);
 185
 186   BOOST_ASIO_CONSTEXPR bool b8 = exec::can_set_error<
 187       const non_const_member_set_error&, boost::system::error_code>::value;
 188   BOOST_ASIO_CHECK(b8 == false);
 189
 190   BOOST_ASIO_CONSTEXPR bool b9 = exec::can_set_error<
 191       free_set_error_non_const_receiver&, boost::system::error_code>::value;
 192   BOOST_ASIO_CHECK(b9 == true);
 193
 194   BOOST_ASIO_CONSTEXPR bool b10 = exec::can_set_error<
 195       const free_set_error_non_const_receiver&, boost::system::error_code>::value;
 196   BOOST_ASIO_CHECK(b10 == false);
 197 }
 198
 199 void increment(int* count)
 200 {
 201   ++(*count);
 202 }
 203
 204 void test_set_error()
 205 {
 206   boost::system::error_code ec;
 207
 208   call_count = 0;
 209   const_member_set_error ex1 = {};
 210   exec::set_error(ex1, ec);
 211   BOOST_ASIO_CHECK(call_count == 1);
 212
 213   call_count = 0;
 214   const const_member_set_error ex2 = {};
 215   exec::set_error(ex2, ec);
 216   BOOST_ASIO_CHECK(call_count == 1);
 217
 218   call_count = 0;
 219   exec::set_error(const_member_set_error(), ec);
 220   BOOST_ASIO_CHECK(call_count == 1);
 221
 222   call_count = 0;
 223   free_set_error_const_receiver ex3 = {};
 224   exec::set_error(ex3, ec);
 225   BOOST_ASIO_CHECK(call_count == 1);
 226
 227   call_count = 0;
 228   const free_set_error_const_receiver ex4 = {};
 229   exec::set_error(ex4, ec);
 230   BOOST_ASIO_CHECK(call_count == 1);
 231
 232   call_count = 0;
 233   exec::set_error(free_set_error_const_receiver(), ec);
 234   BOOST_ASIO_CHECK(call_count == 1);
 235
 236   call_count = 0;
 237   non_const_member_set_error ex5 = {};
 238   exec::set_error(ex5, ec);
 239   BOOST_ASIO_CHECK(call_count == 1);
 240
 241   call_count = 0;
 242   free_set_error_non_const_receiver ex6 = {};
 243   exec::set_error(ex6, ec);
 244   BOOST_ASIO_CHECK(call_count == 1);
 245 }
 246
 247 BOOST_ASIO_TEST_SUITE
 248 (
 249   "set_error",
 250   BOOST_ASIO_TEST_CASE(test_can_set_error)
 251   BOOST_ASIO_TEST_CASE(test_set_error)
 252 )