generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix http://llvm.org/bugs/show_bug.cgi?id=11428. Fix provided by Alberto Ganesh Barbati

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@145698 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant 2011-12-02 19:36:40 +00:00
parent 438377c051
commit f6d875f7f5
11 changed files with 137 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
include/__config
View File

@ -160,6 +160,10 @@ typedef __char32_t char32_t;
#define _LIBCPP_NO_RTTI #define _LIBCPP_NO_RTTI
#endif #endif
#if !(__has_feature(cxx_strong_enums))
#define _LIBCPP_HAS_NO_STRONG_ENUMS
#endif
#if !(__has_feature(cxx_decltype)) #if !(__has_feature(cxx_decltype))
#define _LIBCPP_HAS_NO_DECLTYPE #define _LIBCPP_HAS_NO_DECLTYPE
#endif #endif
@ -223,6 +227,7 @@ typedef __char32_t char32_t;
#if __has_feature(objc_arc_weak) #if __has_feature(objc_arc_weak)
#define _LIBCPP_HAS_OBJC_ARC_WEAK #define _LIBCPP_HAS_OBJC_ARC_WEAK
#define _LIBCPP_HAS_NO_STRONG_ENUMS
#endif #endif
#if !(__has_feature(cxx_constexpr)) #if !(__has_feature(cxx_constexpr))
@ -371,6 +376,18 @@ template <unsigned> struct __static_assert_check {};
#define __has_feature(__x) 0 #define __has_feature(__x) 0
#endif #endif
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
#define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_VISIBLE x { enum _
#define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \
_ __v_; \
_LIBCPP_ALWAYS_INLINE x(_ __v) : __v_(__v) {} \
_LIBCPP_ALWAYS_INLINE operator int() const {return __v_;} \
};
#else // _LIBCPP_HAS_NO_STRONG_ENUMS
#define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_VISIBLE x
#define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)
#endif // _LIBCPP_HAS_NO_STRONG_ENUMS
#if __APPLE__ || __FreeBSD__ || _WIN32 #if __APPLE__ || __FreeBSD__ || _WIN32
#define _LIBCPP_LOCALE__L_EXTENSIONS 1 #define _LIBCPP_LOCALE__L_EXTENSIONS 1
#endif #endif

42
include/future
View File

@ -377,56 +377,40 @@ template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
//enum class future_errc //enum class future_errc
struct _LIBCPP_VISIBLE future_errc _LIBCPP_DECLARE_STRONG_ENUM(future_errc)
{ {
enum _ {
broken_promise, broken_promise,
future_already_retrieved, future_already_retrieved,
promise_already_satisfied, promise_already_satisfied,
no_state no_state
}; };
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
_ __v_;
_LIBCPP_INLINE_VISIBILITY future_errc(_ __v) : __v_(__v) {}
_LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}
};
template <> template <>
struct _LIBCPP_VISIBLE is_error_code_enum<future_errc> : public true_type {}; struct _LIBCPP_VISIBLE is_error_code_enum<future_errc> : public true_type {};
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
template <>
struct _LIBCPP_VISIBLE is_error_code_enum<future_errc::_> : public true_type { };
#endif
//enum class launch //enum class launch
struct _LIBCPP_VISIBLE launch _LIBCPP_DECLARE_STRONG_ENUM(launch)
{ {
enum _ {
async = 1, async = 1,
deferred = 2, deferred = 2,
any = async | deferred any = async | deferred
}; };
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)
_ __v_;
_LIBCPP_INLINE_VISIBILITY launch(_ __v) : __v_(__v) {}
_LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}
};
//enum class future_status //enum class future_status
struct _LIBCPP_VISIBLE future_status _LIBCPP_DECLARE_STRONG_ENUM(future_status)
{ {
enum _ {
ready, ready,
timeout, timeout,
deferred deferred
}; };
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)
_ __v_;
_LIBCPP_INLINE_VISIBILITY future_status(_ __v) : __v_(__v) {}
_LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}
};
_LIBCPP_VISIBLE _LIBCPP_VISIBLE
const error_category& future_category(); const error_category& future_category();
@ -2252,10 +2236,10 @@ async(launch __policy, _Fp&& __f, _Args&&... __args)
typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF; typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF;
typedef typename _BF::_Rp _Rp; typedef typename _BF::_Rp _Rp;
future<_Rp> __r; future<_Rp> __r;
if (__policy & launch::async) if (int(__policy) & int(launch::async))
__r = _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), __r = _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
__decay_copy(_VSTD::forward<_Args>(__args))...)); __decay_copy(_VSTD::forward<_Args>(__args))...));
else if (__policy & launch::deferred) else if (int(__policy) & int(launch::deferred))
__r = _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), __r = _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
__decay_copy(_VSTD::forward<_Args>(__args))...)); __decay_copy(_VSTD::forward<_Args>(__args))...));
return __r; return __r;

12
include/ios
View File

@ -373,21 +373,19 @@ private:
}; };
//enum class io_errc //enum class io_errc
struct _LIBCPP_VISIBLE io_errc _LIBCPP_DECLARE_STRONG_ENUM(io_errc)
{ {
enum _ {
stream = 1 stream = 1
}; };
_ __v_; _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)
_LIBCPP_ALWAYS_INLINE io_errc(_ __v) : __v_(__v) {}
_LIBCPP_ALWAYS_INLINE operator int() const {return __v_;}
};
template <> template <>
struct _LIBCPP_VISIBLE is_error_code_enum<io_errc> : public true_type { }; struct _LIBCPP_VISIBLE is_error_code_enum<io_errc> : public true_type { };
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
template <> template <>
struct _LIBCPP_VISIBLE is_error_code_enum<io_errc::_> : public true_type { }; struct _LIBCPP_VISIBLE is_error_code_enum<io_errc::_> : public true_type { };
#endif
_LIBCPP_VISIBLE _LIBCPP_VISIBLE
const error_category& iostream_category(); const error_category& iostream_category();

15
include/system_error
View File

@ -245,9 +245,8 @@ struct _LIBCPP_VISIBLE is_error_condition_enum
// for them: // for them:
//enum class errc //enum class errc
struct errc _LIBCPP_DECLARE_STRONG_ENUM(errc)
{ {
enum _ {
address_family_not_supported = EAFNOSUPPORT, address_family_not_supported = EAFNOSUPPORT,
address_in_use = EADDRINUSE, address_in_use = EADDRINUSE,
address_not_available = EADDRNOTAVAIL, address_not_available = EADDRNOTAVAIL,
@ -343,23 +342,17 @@ enum _ {
value_too_large = EOVERFLOW, value_too_large = EOVERFLOW,
wrong_protocol_type = EPROTOTYPE wrong_protocol_type = EPROTOTYPE
}; };
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
_ __v_;
_LIBCPP_ALWAYS_INLINE
errc(_ __v) : __v_(__v) {}
_LIBCPP_ALWAYS_INLINE
operator int() const {return __v_;}
};
template <> template <>
struct _LIBCPP_VISIBLE is_error_condition_enum<errc> struct _LIBCPP_VISIBLE is_error_condition_enum<errc>
: true_type { }; : true_type { };
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
template <> template <>
struct _LIBCPP_VISIBLE is_error_condition_enum<errc::_> struct _LIBCPP_VISIBLE is_error_condition_enum<errc::_>
: true_type { }; : true_type { };
#endif
class error_condition; class error_condition;
class error_code; class error_code;

156
test/diagnostics/syserr/errc.pass.cpp
View File

@ -15,90 +15,90 @@
int main() int main()
{ {
static_assert(std::errc::address_family_not_supported == EAFNOSUPPORT, ""); static_assert(static_cast<int>(std::errc::address_family_not_supported) == EAFNOSUPPORT, "");
static_assert(std::errc::address_in_use == EADDRINUSE, ""); static_assert(static_cast<int>(std::errc::address_in_use) == EADDRINUSE, "");
static_assert(std::errc::address_not_available == EADDRNOTAVAIL, ""); static_assert(static_cast<int>(std::errc::address_not_available) == EADDRNOTAVAIL, "");
static_assert(std::errc::already_connected == EISCONN, ""); static_assert(static_cast<int>(std::errc::already_connected) == EISCONN, "");
static_assert(std::errc::argument_list_too_long == E2BIG, ""); static_assert(static_cast<int>(std::errc::argument_list_too_long) == E2BIG, "");
static_assert(std::errc::argument_out_of_domain == EDOM, ""); static_assert(static_cast<int>(std::errc::argument_out_of_domain) == EDOM, "");
static_assert(std::errc::bad_address == EFAULT, ""); static_assert(static_cast<int>(std::errc::bad_address) == EFAULT, "");
static_assert(std::errc::bad_file_descriptor == EBADF, ""); static_assert(static_cast<int>(std::errc::bad_file_descriptor) == EBADF, "");
static_assert(std::errc::bad_message == EBADMSG, ""); static_assert(static_cast<int>(std::errc::bad_message) == EBADMSG, "");
static_assert(std::errc::broken_pipe == EPIPE, ""); static_assert(static_cast<int>(std::errc::broken_pipe) == EPIPE, "");
static_assert(std::errc::connection_aborted == ECONNABORTED, ""); static_assert(static_cast<int>(std::errc::connection_aborted) == ECONNABORTED, "");
static_assert(std::errc::connection_already_in_progress == EALREADY, ""); static_assert(static_cast<int>(std::errc::connection_already_in_progress) == EALREADY, "");
static_assert(std::errc::connection_refused == ECONNREFUSED, ""); static_assert(static_cast<int>(std::errc::connection_refused) == ECONNREFUSED, "");
static_assert(std::errc::connection_reset == ECONNRESET, ""); static_assert(static_cast<int>(std::errc::connection_reset) == ECONNRESET, "");
static_assert(std::errc::cross_device_link == EXDEV, ""); static_assert(static_cast<int>(std::errc::cross_device_link) == EXDEV, "");
static_assert(std::errc::destination_address_required == EDESTADDRREQ, ""); static_assert(static_cast<int>(std::errc::destination_address_required) == EDESTADDRREQ, "");
static_assert(std::errc::device_or_resource_busy == EBUSY, ""); static_assert(static_cast<int>(std::errc::device_or_resource_busy) == EBUSY, "");
static_assert(std::errc::directory_not_empty == ENOTEMPTY, ""); static_assert(static_cast<int>(std::errc::directory_not_empty) == ENOTEMPTY, "");
static_assert(std::errc::executable_format_error == ENOEXEC, ""); static_assert(static_cast<int>(std::errc::executable_format_error) == ENOEXEC, "");
static_assert(std::errc::file_exists == EEXIST, ""); static_assert(static_cast<int>(std::errc::file_exists) == EEXIST, "");
static_assert(std::errc::file_too_large == EFBIG, ""); static_assert(static_cast<int>(std::errc::file_too_large) == EFBIG, "");
static_assert(std::errc::filename_too_long == ENAMETOOLONG, ""); static_assert(static_cast<int>(std::errc::filename_too_long) == ENAMETOOLONG, "");
static_assert(std::errc::function_not_supported == ENOSYS, ""); static_assert(static_cast<int>(std::errc::function_not_supported) == ENOSYS, "");
static_assert(std::errc::host_unreachable == EHOSTUNREACH, ""); static_assert(static_cast<int>(std::errc::host_unreachable) == EHOSTUNREACH, "");
static_assert(std::errc::identifier_removed == EIDRM, ""); static_assert(static_cast<int>(std::errc::identifier_removed) == EIDRM, "");
static_assert(std::errc::illegal_byte_sequence == EILSEQ, ""); static_assert(static_cast<int>(std::errc::illegal_byte_sequence) == EILSEQ, "");
static_assert(std::errc::inappropriate_io_control_operation == ENOTTY, ""); static_assert(static_cast<int>(std::errc::inappropriate_io_control_operation) == ENOTTY, "");
static_assert(std::errc::interrupted == EINTR, ""); static_assert(static_cast<int>(std::errc::interrupted) == EINTR, "");
static_assert(std::errc::invalid_argument == EINVAL, ""); static_assert(static_cast<int>(std::errc::invalid_argument) == EINVAL, "");
static_assert(std::errc::invalid_seek == ESPIPE, ""); static_assert(static_cast<int>(std::errc::invalid_seek) == ESPIPE, "");
static_assert(std::errc::io_error == EIO, ""); static_assert(static_cast<int>(std::errc::io_error) == EIO, "");
static_assert(std::errc::is_a_directory == EISDIR, ""); static_assert(static_cast<int>(std::errc::is_a_directory) == EISDIR, "");
static_assert(std::errc::message_size == EMSGSIZE, ""); static_assert(static_cast<int>(std::errc::message_size) == EMSGSIZE, "");
static_assert(std::errc::network_down == ENETDOWN, ""); static_assert(static_cast<int>(std::errc::network_down) == ENETDOWN, "");
static_assert(std::errc::network_reset == ENETRESET, ""); static_assert(static_cast<int>(std::errc::network_reset) == ENETRESET, "");
static_assert(std::errc::network_unreachable == ENETUNREACH, ""); static_assert(static_cast<int>(std::errc::network_unreachable) == ENETUNREACH, "");
static_assert(std::errc::no_buffer_space == ENOBUFS, ""); static_assert(static_cast<int>(std::errc::no_buffer_space) == ENOBUFS, "");
static_assert(std::errc::no_child_process == ECHILD, ""); static_assert(static_cast<int>(std::errc::no_child_process) == ECHILD, "");
static_assert(std::errc::no_link == ENOLINK, ""); static_assert(static_cast<int>(std::errc::no_link) == ENOLINK, "");
static_assert(std::errc::no_lock_available == ENOLCK, ""); static_assert(static_cast<int>(std::errc::no_lock_available) == ENOLCK, "");
#if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1) #if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1)
static_assert(std::errc::no_message_available == ENODATA, ""); static_assert(static_cast<int>(std::errc::no_message_available) == ENODATA, "");
#endif #endif
static_assert(std::errc::no_message == ENOMSG, ""); static_assert(static_cast<int>(std::errc::no_message) == ENOMSG, "");
static_assert(std::errc::no_protocol_option == ENOPROTOOPT, ""); static_assert(static_cast<int>(std::errc::no_protocol_option) == ENOPROTOOPT, "");
static_assert(std::errc::no_space_on_device == ENOSPC, ""); static_assert(static_cast<int>(std::errc::no_space_on_device) == ENOSPC, "");
#if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1) #if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1)
static_assert(std::errc::no_stream_resources == ENOSR, ""); static_assert(static_cast<int>(std::errc::no_stream_resources) == ENOSR, "");
#endif #endif
static_assert(std::errc::no_such_device_or_address == ENXIO, ""); static_assert(static_cast<int>(std::errc::no_such_device_or_address) == ENXIO, "");
static_assert(std::errc::no_such_device == ENODEV, ""); static_assert(static_cast<int>(std::errc::no_such_device) == ENODEV, "");
static_assert(std::errc::no_such_file_or_directory == ENOENT, ""); static_assert(static_cast<int>(std::errc::no_such_file_or_directory) == ENOENT, "");
static_assert(std::errc::no_such_process == ESRCH, ""); static_assert(static_cast<int>(std::errc::no_such_process) == ESRCH, "");
static_assert(std::errc::not_a_directory == ENOTDIR, ""); static_assert(static_cast<int>(std::errc::not_a_directory) == ENOTDIR, "");
static_assert(std::errc::not_a_socket == ENOTSOCK, ""); static_assert(static_cast<int>(std::errc::not_a_socket) == ENOTSOCK, "");
#if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1) #if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1)
static_assert(std::errc::not_a_stream == ENOSTR, ""); static_assert(static_cast<int>(std::errc::not_a_stream) == ENOSTR, "");
#endif #endif
static_assert(std::errc::not_connected == ENOTCONN, ""); static_assert(static_cast<int>(std::errc::not_connected) == ENOTCONN, "");
static_assert(std::errc::not_enough_memory == ENOMEM, ""); static_assert(static_cast<int>(std::errc::not_enough_memory) == ENOMEM, "");
static_assert(std::errc::not_supported == ENOTSUP, ""); static_assert(static_cast<int>(std::errc::not_supported) == ENOTSUP, "");
static_assert(std::errc::operation_canceled == ECANCELED, ""); static_assert(static_cast<int>(std::errc::operation_canceled) == ECANCELED, "");
static_assert(std::errc::operation_in_progress == EINPROGRESS, ""); static_assert(static_cast<int>(std::errc::operation_in_progress) == EINPROGRESS, "");
static_assert(std::errc::operation_not_permitted == EPERM, ""); static_assert(static_cast<int>(std::errc::operation_not_permitted) == EPERM, "");
static_assert(std::errc::operation_not_supported == EOPNOTSUPP, ""); static_assert(static_cast<int>(std::errc::operation_not_supported) == EOPNOTSUPP, "");
static_assert(std::errc::operation_would_block == EWOULDBLOCK, ""); static_assert(static_cast<int>(std::errc::operation_would_block) == EWOULDBLOCK, "");
static_assert(std::errc::owner_dead == EOWNERDEAD, ""); static_assert(static_cast<int>(std::errc::owner_dead) == EOWNERDEAD, "");
static_assert(std::errc::permission_denied == EACCES, ""); static_assert(static_cast<int>(std::errc::permission_denied) == EACCES, "");
static_assert(std::errc::protocol_error == EPROTO, ""); static_assert(static_cast<int>(std::errc::protocol_error) == EPROTO, "");
static_assert(std::errc::protocol_not_supported == EPROTONOSUPPORT, ""); static_assert(static_cast<int>(std::errc::protocol_not_supported) == EPROTONOSUPPORT, "");
static_assert(std::errc::read_only_file_system == EROFS, ""); static_assert(static_cast<int>(std::errc::read_only_file_system) == EROFS, "");
static_assert(std::errc::resource_deadlock_would_occur == EDEADLK, ""); static_assert(static_cast<int>(std::errc::resource_deadlock_would_occur) == EDEADLK, "");
static_assert(std::errc::resource_unavailable_try_again == EAGAIN, ""); static_assert(static_cast<int>(std::errc::resource_unavailable_try_again) == EAGAIN, "");
static_assert(std::errc::result_out_of_range == ERANGE, ""); static_assert(static_cast<int>(std::errc::result_out_of_range) == ERANGE, "");
static_assert(std::errc::state_not_recoverable == ENOTRECOVERABLE, ""); static_assert(static_cast<int>(std::errc::state_not_recoverable) == ENOTRECOVERABLE, "");
#if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1) #if (defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1)
static_assert(std::errc::stream_timeout == ETIME, ""); static_assert(static_cast<int>(std::errc::stream_timeout) == ETIME, "");
#endif #endif
static_assert(std::errc::text_file_busy == ETXTBSY, ""); static_assert(static_cast<int>(std::errc::text_file_busy) == ETXTBSY, "");
static_assert(std::errc::timed_out == ETIMEDOUT, ""); static_assert(static_cast<int>(std::errc::timed_out) == ETIMEDOUT, "");
static_assert(std::errc::too_many_files_open_in_system == ENFILE, ""); static_assert(static_cast<int>(std::errc::too_many_files_open_in_system) == ENFILE, "");
static_assert(std::errc::too_many_files_open == EMFILE, ""); static_assert(static_cast<int>(std::errc::too_many_files_open) == EMFILE, "");
static_assert(std::errc::too_many_links == EMLINK, ""); static_assert(static_cast<int>(std::errc::too_many_links) == EMLINK, "");
static_assert(std::errc::too_many_symbolic_link_levels == ELOOP, ""); static_assert(static_cast<int>(std::errc::too_many_symbolic_link_levels) == ELOOP, "");
static_assert(std::errc::value_too_large == EOVERFLOW, ""); static_assert(static_cast<int>(std::errc::value_too_large) == EOVERFLOW, "");
static_assert(std::errc::wrong_protocol_type == EPROTOTYPE, ""); static_assert(static_cast<int>(std::errc::wrong_protocol_type) == EPROTOTYPE, "");
} }

4
test/diagnostics/syserr/syserr.errcat/syserr.errcat.virtuals/default_error_condition.pass.cpp
View File

@ -19,7 +19,7 @@
int main() int main()
{ {
const std::error_category& e_cat = std::generic_category(); const std::error_category& e_cat = std::generic_category();
std::error_condition e_cond = e_cat.default_error_condition(std::errc::not_a_directory); std::error_condition e_cond = e_cat.default_error_condition(static_cast<int>(std::errc::not_a_directory));
assert(e_cond.category() == e_cat); assert(e_cond.category() == e_cat);
assert(e_cond.value() == std::errc::not_a_directory); assert(e_cond.value() == static_cast<int>(std::errc::not_a_directory));
} }

4
test/thread/futures/futures.errors/default_error_condition.pass.cpp
View File

@ -19,7 +19,7 @@
int main() int main()
{ {
const std::error_category& e_cat = std::future_category(); const std::error_category& e_cat = std::future_category();
std::error_condition e_cond = e_cat.default_error_condition(std::errc::not_a_directory); std::error_condition e_cond = e_cat.default_error_condition(static_cast<int>(std::errc::not_a_directory));
assert(e_cond.category() == e_cat); assert(e_cond.category() == e_cat);
assert(e_cond.value() == std::errc::not_a_directory); assert(e_cond.value() == static_cast<int>(std::errc::not_a_directory));
} }

8
test/thread/futures/futures.overview/future_errc.pass.cpp
View File

@ -21,8 +21,8 @@
int main() int main()
{ {
static_assert(std::future_errc::broken_promise == 0, ""); static_assert(static_cast<int>(std::future_errc::broken_promise) == 0, "");
static_assert(std::future_errc::future_already_retrieved == 1, ""); static_assert(static_cast<int>(std::future_errc::future_already_retrieved) == 1, "");
static_assert(std::future_errc::promise_already_satisfied == 2, ""); static_assert(static_cast<int>(std::future_errc::promise_already_satisfied) == 2, "");
static_assert(std::future_errc::no_state == 3, ""); static_assert(static_cast<int>(std::future_errc::no_state) == 3, "");
} }

6
test/thread/futures/futures.overview/future_status.pass.cpp
View File

@ -20,7 +20,7 @@
int main() int main()
{ {
static_assert(std::future_status::ready == 0, ""); static_assert(static_cast<int>(std::future_status::ready) == 0, "");
static_assert(std::future_status::timeout == 1, ""); static_assert(static_cast<int>(std::future_status::timeout) == 1, "");
static_assert(std::future_status::deferred == 2, ""); static_assert(static_cast<int>(std::future_status::deferred) == 2, "");
} }

7
test/thread/futures/futures.overview/launch.pass.cpp
View File

@ -20,7 +20,8 @@
int main() int main()
{ {
static_assert(std::launch::any == (std::launch::async | std::launch::deferred), ""); static_assert(static_cast<int>(std::launch::any) ==
static_assert(std::launch::async == 1, ""); (static_cast<int>(std::launch::async) | static_cast<int>(std::launch::deferred)), "");
static_assert(std::launch::deferred == 2, ""); static_assert(static_cast<int>(std::launch::async) == 1, "");
static_assert(static_cast<int>(std::launch::deferred) == 2, "");
} }