boostorg/beast
1
0
Fork 1
mirror of https://github.com/boostorg/beast.git synced 2026-08-03 20:14:17 +02:00
Code Issues Packages Projects Releases Wiki Activity

replace BOOST_STATIC_ASSERT with BOOST_CORE_STATIC_ASSERT

Browse Source 
Closes #3048
This commit is contained in:
Mohammad Nejati
2025-10-22 14:39:02 +00:00
committed by Mohammad Nejati
parent 63f3d3f393
commit b687af73c3
45 changed files with 261 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
-1
View File
@@ -69,7 +69,6 @@ set(BOOST_BEAST_DEPENDENCIES
Boost::optional
Boost::preprocessor
Boost::smart_ptr
Boost::static_assert
Boost::static_string
Boost::system
Boost::throw_exception
build.jam
-1
View File
@@ -22,7 +22,6 @@ constant boost_dependencies :
/boost/optional//boost_optional
/boost/preprocessor//boost_preprocessor
/boost/smart_ptr//boost_smart_ptr
/boost/static_assert//boost_static_assert
/boost/static_string//boost_static_string
/boost/system//boost_system
/boost/throw_exception//boost_throw_exception
include/boost/beast/core/detail/config.hpp
+1 -1
View File
@@ -14,7 +14,7 @@
#include <boost/config.hpp>
#include <boost/version.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/static_assert.hpp>
#include <boost/core/detail/static_assert.hpp>
#include <boost/preprocessor/cat.hpp>
namespace boost {
include/boost/beast/core/detail/remap_post_to_defer.hpp
+1 -1
View File
@@ -23,7 +23,7 @@ template<class Executor>
class remap_post_to_defer
: private boost::empty_value<Executor>
{
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_executor<Executor>::value);
Executor const&
include/boost/beast/core/detail/varint.hpp
+3 -3
View File
@@ -10,7 +10,7 @@
#ifndef BOOST_BEAST_DETAIL_VARINT_HPP
#define BOOST_BEAST_DETAIL_VARINT_HPP
#include <boost/static_assert.hpp>
#include <boost/core/detail/static_assert.hpp>
#include <cstdlib>
#include <iterator>
#include <type_traits>
@@ -40,7 +40,7 @@ varint_read(FwdIt& first)
{
using value_type = typename
std::iterator_traits<FwdIt>::value_type;
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_integral<value_type>::value &&
sizeof(value_type) == 1);
std::size_t value = 0;
@@ -60,7 +60,7 @@ varint_write(FwdIt& first, std::size_t value)
{
using value_type = typename
std::iterator_traits<FwdIt>::value_type;
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_integral<value_type>::value &&
sizeof(value_type) == 1);
while(value > 127)
include/boost/beast/core/flat_stream.hpp
+1 -1
View File
@@ -95,7 +95,7 @@ class flat_stream
NextLayer stream_;
flat_buffer buffer_;
BOOST_STATIC_ASSERT(has_get_executor<NextLayer>::value);
BOOST_CORE_STATIC_ASSERT(has_get_executor<NextLayer>::value);
struct ops;
include/boost/beast/core/impl/buffers_prefix.hpp
+2 -2
View File
@@ -43,7 +43,7 @@ public:
using value_type = buffers_type<Buffers>;
#endif
BOOST_STATIC_ASSERT(std::is_same<
BOOST_CORE_STATIC_ASSERT(std::is_same<
typename const_iterator::value_type,
typename buffers_prefix_view::value_type>::value);
@@ -156,7 +156,7 @@ setup(std::size_t size)
size_ += size;
// by design, this subtraction can wrap
BOOST_STATIC_ASSERT(std::is_unsigned<
BOOST_CORE_STATIC_ASSERT(std::is_unsigned<
decltype(remain_)>::value);
remain_ = size - len;
break;
include/boost/beast/core/rate_policy.hpp
+1 -1
View File
@@ -11,7 +11,7 @@
#define BOOST_BEAST_CORE_RATE_POLICY_HPP
#include <boost/beast/core/detail/config.hpp>
#include <cstdint>
#include <cstddef>
#include <limits>
namespace boost {
include/boost/beast/http/detail/rfc7230.ipp
+7 -7
View File
@@ -46,7 +46,7 @@ is_alpha(char c)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 224
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // 240
};
BOOST_STATIC_ASSERT(sizeof(tab) == 256);
BOOST_CORE_STATIC_ASSERT(sizeof(tab) == 256);
return tab[static_cast<unsigned char>(c)];
}
@@ -72,7 +72,7 @@ is_text(char c)
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 224
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 240
};
BOOST_STATIC_ASSERT(sizeof(tab) == 256);
BOOST_CORE_STATIC_ASSERT(sizeof(tab) == 256);
return tab[static_cast<unsigned char>(c)];
}
@@ -103,7 +103,7 @@ is_token_char(char c)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 224
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // 240
};
BOOST_STATIC_ASSERT(sizeof(tab) == 256);
BOOST_CORE_STATIC_ASSERT(sizeof(tab) == 256);
return tab[static_cast<unsigned char>(c)];
}
@@ -131,7 +131,7 @@ is_qdchar(char c)
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 224
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 240
};
BOOST_STATIC_ASSERT(sizeof(tab) == 256);
BOOST_CORE_STATIC_ASSERT(sizeof(tab) == 256);
return tab[static_cast<unsigned char>(c)];
}
@@ -160,7 +160,7 @@ is_qpchar(char c)
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 224
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 240
};
BOOST_STATIC_ASSERT(sizeof(tab) == 256);
BOOST_CORE_STATIC_ASSERT(sizeof(tab) == 256);
return tab[static_cast<unsigned char>(c)];
}
@@ -189,7 +189,7 @@ to_value_char(char c)
224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, // 224
240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 // 240
};
BOOST_STATIC_ASSERT(sizeof(tab) == 256);
BOOST_CORE_STATIC_ASSERT(sizeof(tab) == 256);
return static_cast<char>(tab[static_cast<unsigned char>(c)]);
}
@@ -215,7 +215,7 @@ unhex(char c)
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 224
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 // 240
};
BOOST_STATIC_ASSERT(sizeof(tab) == 256);
BOOST_CORE_STATIC_ASSERT(sizeof(tab) == 256);
return tab[static_cast<unsigned char>(c)];
}
include/boost/beast/http/impl/fields.ipp
+1 -1
View File
@@ -20,7 +20,7 @@ namespace detail {
// `basic_fields` assumes that `std::size_t` is larger than `uint16_t`, so we
// verify it explicitly here, so that users that use split compilation don't
// need to pay the (fairly small) price for this sanity check
BOOST_STATIC_ASSERT((std::numeric_limits<std::size_t>::max)() >=
BOOST_CORE_STATIC_ASSERT((std::numeric_limits<std::size_t>::max)() >=
(std::numeric_limits<std::uint32_t>::max)());
// Filter a token list
include/boost/beast/http/parser.hpp
+2 -2
View File
@@ -248,7 +248,7 @@ public:
{
// Callback may not be constant, caller is responsible for
// managing the lifetime of the callback. Copies are not made.
BOOST_STATIC_ASSERT(! std::is_const<Callback>::value);
BOOST_CORE_STATIC_ASSERT(! std::is_const<Callback>::value);
// Can't set the callback after receiving any chunk data!
BOOST_ASSERT(! rd_inited_);
@@ -296,7 +296,7 @@ public:
{
// Callback may not be constant, caller is responsible for
// managing the lifetime of the callback. Copies are not made.
BOOST_STATIC_ASSERT(! std::is_const<Callback>::value);
BOOST_CORE_STATIC_ASSERT(! std::is_const<Callback>::value);
// Can't set the callback after receiving any chunk data!
BOOST_ASSERT(! rd_inited_);
include/boost/beast/websocket/option.hpp
+2
View File
@@ -12,6 +12,8 @@
#include <boost/beast/core/detail/config.hpp>
#include <cstddef>
namespace boost {
namespace beast {
namespace websocket {
include/boost/beast/zlib/detail/deflate_stream.hpp
+2 -2
View File
@@ -87,7 +87,7 @@ protected:
static std::uint16_t constexpr maxMatch = 258;
// Can't change minMatch without also changing code, see original zlib
BOOST_STATIC_ASSERT(minMatch == 3);
BOOST_CORE_STATIC_ASSERT(minMatch == 3);
// end of block literal code
static std::uint16_t constexpr end_block = 256;
@@ -698,7 +698,7 @@ Unsigned
deflate_stream::
bi_reverse(Unsigned code, unsigned len)
{
BOOST_STATIC_ASSERT(std::is_unsigned<Unsigned>::value);
BOOST_CORE_STATIC_ASSERT(std::is_unsigned<Unsigned>::value);
BOOST_ASSERT(len <= 8 * sizeof(unsigned));
Unsigned res = 0;
do
test/beast/_experimental/stream.cpp
+1 -1
View File
@@ -150,7 +150,7 @@ public:
void
testAsioSSLCompat()
{
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
boost::asio::ssl::stream<test::stream>::
lowest_layer_type,
test/beast/core/_detail_is_invocable.cpp
+8 -8
View File
@@ -43,14 +43,14 @@ struct is_invocable_udt4
#ifndef __INTELLISENSE__
// VFALCO Fails to compile with Intellisense
BOOST_STATIC_ASSERT(is_invocable<is_invocable_udt1, void(int)>::value);
BOOST_STATIC_ASSERT(is_invocable<is_invocable_udt2, int(int)>::value);
BOOST_STATIC_ASSERT(is_invocable<is_invocable_udt3, int(int)>::value);
BOOST_STATIC_ASSERT(! is_invocable<is_invocable_udt1, void(void)>::value);
BOOST_STATIC_ASSERT(! is_invocable<is_invocable_udt2, int(void)>::value);
BOOST_STATIC_ASSERT(! is_invocable<is_invocable_udt2, void(void)>::value);
BOOST_STATIC_ASSERT(! is_invocable<is_invocable_udt3 const, int(int)>::value);
BOOST_STATIC_ASSERT(is_invocable<is_invocable_udt4, void(std::unique_ptr<int>)>::value);
BOOST_CORE_STATIC_ASSERT(is_invocable<is_invocable_udt1, void(int)>::value);
BOOST_CORE_STATIC_ASSERT(is_invocable<is_invocable_udt2, int(int)>::value);
BOOST_CORE_STATIC_ASSERT(is_invocable<is_invocable_udt3, int(int)>::value);
BOOST_CORE_STATIC_ASSERT(! is_invocable<is_invocable_udt1, void(void)>::value);
BOOST_CORE_STATIC_ASSERT(! is_invocable<is_invocable_udt2, int(void)>::value);
BOOST_CORE_STATIC_ASSERT(! is_invocable<is_invocable_udt2, void(void)>::value);
BOOST_CORE_STATIC_ASSERT(! is_invocable<is_invocable_udt3 const, int(int)>::value);
BOOST_CORE_STATIC_ASSERT(is_invocable<is_invocable_udt4, void(std::unique_ptr<int>)>::value);
#endif
} // (anonymous)
test/beast/core/async_base.cpp
+20 -20
View File
@@ -83,7 +83,7 @@ struct ex1_type
operator!=(ex1_type const &) const noexcept
{ return false; }
};
BOOST_STATIC_ASSERT(net::execution::is_executor<ex1_type>::value);
BOOST_CORE_STATIC_ASSERT(net::execution::is_executor<ex1_type>::value);
#else
struct ex1_type
{
@@ -94,7 +94,7 @@ struct ex1_type
template<class F> void post(F&&) {}
template<class F> void defer(F&&) {}
};
BOOST_STATIC_ASSERT(net::is_executor<ex1_type>::value);
BOOST_CORE_STATIC_ASSERT(net::is_executor<ex1_type>::value);
#endif
@@ -251,7 +251,7 @@ class async_base_test : public beast::unit_test::suite
public:
// no associated allocator
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
std::allocator<void>,
net::associated_allocator_t<
@@ -260,7 +260,7 @@ public:
net::io_context::executor_type>
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
std::allocator<int>,
net::associated_allocator_t<
@@ -270,7 +270,7 @@ public:
std::allocator<int>>
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
std::allocator<void>,
net::associated_allocator_t<
@@ -280,7 +280,7 @@ public:
std::allocator<int> // ignored
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
std::allocator<int>,
net::associated_allocator_t<
@@ -293,7 +293,7 @@ public:
// nested associated allocator
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
nested_alloc::allocator_type,
net::associated_allocator_t<
@@ -302,7 +302,7 @@ public:
net::io_context::executor_type>
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
nested_alloc::allocator_type,
net::associated_allocator_t<
@@ -312,7 +312,7 @@ public:
std::allocator<int>> // ignored
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
nested_alloc::allocator_type,
net::associated_allocator_t<
@@ -322,7 +322,7 @@ public:
std::allocator<int> // ignored
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
nested_alloc::allocator_type,
net::associated_allocator_t<
@@ -335,7 +335,7 @@ public:
// intrusive associated allocator
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
intrusive_alloc::allocator_type,
net::associated_allocator_t<
@@ -344,7 +344,7 @@ public:
net::io_context::executor_type>
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
intrusive_alloc::allocator_type,
net::associated_allocator_t<
@@ -354,7 +354,7 @@ public:
std::allocator<int>> // ignored
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
intrusive_alloc::allocator_type,
net::associated_allocator_t<
@@ -364,7 +364,7 @@ public:
std::allocator<int> // ignored
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
intrusive_alloc::allocator_type,
net::associated_allocator_t<
@@ -377,7 +377,7 @@ public:
// no associated executor
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
ex1_type,
net::associated_executor_t<
@@ -386,7 +386,7 @@ public:
ex1_type>
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
ex1_type,
net::associated_executor_t<
@@ -398,7 +398,7 @@ public:
// nested associated executor
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
nested_ex::executor_type,
net::associated_executor_t<
@@ -407,7 +407,7 @@ public:
ex1_type>
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
nested_ex::executor_type,
net::associated_executor_t<
@@ -419,7 +419,7 @@ public:
// intrusive associated executor
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
intrusive_ex::executor_type,
net::associated_executor_t<
@@ -428,7 +428,7 @@ public:
ex1_type>
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<
intrusive_ex::executor_type,
net::associated_executor_t<
test/beast/core/basic_stream.cpp
+1 -1
View File
@@ -1267,7 +1267,7 @@ public:
net::strand<
net::io_context::executor_type>,
unlimited_rate_policy> stream(std::move(sock));
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_convertible<
decltype(sock)::executor_type,
decltype(stream)::executor_type>::value);
test/beast/core/bind_handler.cpp
+2 -2
View File
@@ -249,9 +249,9 @@ public:
};
#if defined(BOOST_ASIO_NO_TS_EXECUTORS)
BOOST_STATIC_ASSERT(net::execution::is_executor<test_executor>::value);
BOOST_CORE_STATIC_ASSERT(net::execution::is_executor<test_executor>::value);
#else
BOOST_STATIC_ASSERT(net::is_executor<test_executor>::value);
BOOST_CORE_STATIC_ASSERT(net::is_executor<test_executor>::value);
#endif
class test_cb
test/beast/core/buffer_traits.cpp
+27 -27
View File
@@ -56,120 +56,120 @@ class buffer_traits_test : public beast::unit_test::suite
public:
// is_const_buffer_sequence
BOOST_STATIC_ASSERT(is_const_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_const_buffer_sequence<
>::value);
BOOST_STATIC_ASSERT(is_const_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_const_buffer_sequence<
net::const_buffer
>::value);
BOOST_STATIC_ASSERT(is_const_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_const_buffer_sequence<
net::const_buffer, net::const_buffer
>::value);
BOOST_STATIC_ASSERT(is_const_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_const_buffer_sequence<
net::const_buffer, net::mutable_buffer
>::value);
BOOST_STATIC_ASSERT(is_const_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_const_buffer_sequence<
net::mutable_buffer, net::mutable_buffer
>::value);
BOOST_STATIC_ASSERT(is_const_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_const_buffer_sequence<
net::const_buffer const&
>::value);
BOOST_STATIC_ASSERT(is_const_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_const_buffer_sequence<
net::const_buffer const&, net::const_buffer const&
>::value);
BOOST_STATIC_ASSERT(is_const_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_const_buffer_sequence<
net::const_buffer const&, net::mutable_buffer const&
>::value);
// is_mutable_buffer_sequence
BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_mutable_buffer_sequence<
>::value);
BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_mutable_buffer_sequence<
net::mutable_buffer
>::value);
BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_mutable_buffer_sequence<
net::mutable_buffer, net::mutable_buffer
>::value);
BOOST_STATIC_ASSERT(! is_mutable_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(! is_mutable_buffer_sequence<
net::const_buffer, net::const_buffer
>::value);
BOOST_STATIC_ASSERT(! is_mutable_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(! is_mutable_buffer_sequence<
net::const_buffer, net::mutable_buffer
>::value);
BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_mutable_buffer_sequence<
net::mutable_buffer const&
>::value);
BOOST_STATIC_ASSERT(is_mutable_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(is_mutable_buffer_sequence<
net::mutable_buffer const&, net::mutable_buffer const&
>::value);
// buffers_type
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::const_buffer, buffers_type<
net::const_buffer
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::const_buffer, buffers_type<
net::const_buffer, net::const_buffer
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::const_buffer, buffers_type<
net::const_buffer, net::mutable_buffer
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::mutable_buffer, buffers_type<
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::mutable_buffer, buffers_type<
net::mutable_buffer
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::mutable_buffer, buffers_type<
net::mutable_buffer, net::mutable_buffer
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::const_buffer, buffers_type<
std::array<net::const_buffer, 3>
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::mutable_buffer, buffers_type<
std::array<net::mutable_buffer, 3>
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::const_buffer, buffers_type<
std::array<int, 3>
>>::value);
// buffers_iterator_type
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::const_buffer const*, buffers_iterator_type<
net::const_buffer
>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_same<net::mutable_buffer const*, buffers_iterator_type<
net::mutable_buffer
>>::value);
@@ -224,7 +224,7 @@ public:
BEAST_EXPECT(buffer_bytes(s) == 26);
}
BOOST_STATIC_ASSERT(! detail::is_invocable<
BOOST_CORE_STATIC_ASSERT(! detail::is_invocable<
detail::buffer_bytes_impl,
std::size_t(not_sequence const&)>::value);
}
test/beast/core/buffers_adaptor.cpp
+1 -1
View File
@@ -57,7 +57,7 @@ struct buffers_adaptor_test_hook
class buffers_adaptor_test : public unit_test::suite
{
public:
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_mutable_dynamic_buffer<
buffers_adaptor<buffers_triple>>::value);
test/beast/core/buffers_range.cpp
+4 -4
View File
@@ -20,22 +20,22 @@ namespace beast {
class buffers_range_test : public beast::unit_test::suite
{
public:
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_const_buffer_sequence<
decltype(beast::buffers_range(
std::declval<net::const_buffer>()))>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_const_buffer_sequence<
decltype(beast::buffers_range(
std::declval<net::mutable_buffer>()))>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
! net::is_mutable_buffer_sequence<
decltype(beast::buffers_range(
std::declval<net::const_buffer>()))>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_mutable_buffer_sequence<
decltype(beast::buffers_range(
std::declval<net::mutable_buffer>()))>::value);
test/beast/core/file_posix.cpp
+1 -1
View File
@@ -19,7 +19,7 @@
namespace boost {
namespace beast {
BOOST_STATIC_ASSERT(! std::is_copy_constructible<file_posix>::value);
BOOST_CORE_STATIC_ASSERT(! std::is_copy_constructible<file_posix>::value);
class file_posix_test
: public beast::unit_test::suite
test/beast/core/file_stdio.cpp
+1 -1
View File
@@ -17,7 +17,7 @@
namespace boost {
namespace beast {
BOOST_STATIC_ASSERT(! std::is_copy_constructible<file_stdio>::value);
BOOST_CORE_STATIC_ASSERT(! std::is_copy_constructible<file_stdio>::value);
class file_stdio_test
: public beast::unit_test::suite
test/beast/core/file_test.hpp
+3 -3
View File
@@ -32,11 +32,11 @@ template<class File, bool append_unicode_suffix = false>
void
test_file()
{
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_file<File>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
! std::is_copy_constructible<File>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
! std::is_copy_assignable<File>::value);
namespace fs = boost::filesystem;
test/beast/core/flat_buffer.cpp
+2 -2
View File
@@ -26,7 +26,7 @@ namespace beast {
class flat_buffer_test : public beast::unit_test::suite
{
public:
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_mutable_dynamic_buffer<flat_buffer>::value);
void
@@ -300,7 +300,7 @@ public:
{
basic_flat_buffer<a_t> b;
auto a = b.get_allocator();
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
! std::is_const<decltype(a)>::value);
a->max_size = 30;
try
test/beast/core/flat_static_buffer.cpp
+1 -1
View File
@@ -28,7 +28,7 @@ namespace beast {
class flat_static_buffer_test : public beast::unit_test::suite
{
public:
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_mutable_dynamic_buffer<
flat_static_buffer<13>>::value);
test/beast/core/multi_buffer.cpp
+4 -4
View File
@@ -32,14 +32,14 @@ namespace beast {
class multi_buffer_test : public beast::unit_test::suite
{
public:
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_mutable_dynamic_buffer<multi_buffer>::value);
#if ! BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 50000) && \
! BOOST_WORKAROUND(BOOST_MSVC, < 1910)
// BOOST_STATIC_ASSERT(std::is_trivially_copyable<
// BOOST_CORE_STATIC_ASSERT(std::is_trivially_copyable<
// multi_buffer::const_buffers_type>::value);
// BOOST_STATIC_ASSERT(std::is_trivially_copyable<
// BOOST_CORE_STATIC_ASSERT(std::is_trivially_copyable<
// multi_buffer::mutable_data_type>::value);
#endif
@@ -379,7 +379,7 @@ public:
{
basic_multi_buffer<equal_t> b;
auto a = b.get_allocator();
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
! std::is_const<decltype(a)>::value);
a->max_size = 30;
try
test/beast/core/static_buffer.cpp
+2 -2
View File
@@ -28,11 +28,11 @@ namespace beast {
class static_buffer_test : public beast::unit_test::suite
{
public:
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_mutable_dynamic_buffer<
static_buffer<13>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_mutable_dynamic_buffer<
static_buffer_base>::value);
test/beast/core/stream_traits.cpp
+32 -32
View File
@@ -65,13 +65,13 @@ public:
}
};
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
! detail::has_next_layer<without>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
detail::has_next_layer<with<without>>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
detail::has_next_layer<with<with<without>>>::value);
void
@@ -169,9 +169,9 @@ public:
testGetLowestLayerJavadoc()
{
write_stream<without> s;
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
is_sync_write_stream<without>::value);
BOOST_STATIC_ASSERT(std::is_same<
BOOST_CORE_STATIC_ASSERT(std::is_same<
decltype(get_lowest_layer(s)), without&>::value);
#if 0
@@ -238,37 +238,37 @@ public:
void async_write_some(ConstBufferSequence const&, WriteHandler&&);
};
BOOST_STATIC_ASSERT(is_sync_read_stream<sync_read_stream>::value);
BOOST_STATIC_ASSERT(is_sync_read_stream<sync_stream>::value);
BOOST_STATIC_ASSERT(is_sync_write_stream<sync_write_stream>::value);
BOOST_STATIC_ASSERT(is_sync_write_stream<sync_stream>::value);
BOOST_STATIC_ASSERT(is_sync_stream<sync_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_sync_read_stream<sync_read_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_sync_read_stream<sync_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_sync_write_stream<sync_write_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_sync_write_stream<sync_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_sync_stream<sync_stream>::value);
BOOST_STATIC_ASSERT(! is_sync_read_stream<sync_write_stream>::value);
BOOST_STATIC_ASSERT(! is_sync_write_stream<sync_read_stream>::value);
BOOST_STATIC_ASSERT(! is_sync_stream<async_stream>::value);
BOOST_CORE_STATIC_ASSERT(! is_sync_read_stream<sync_write_stream>::value);
BOOST_CORE_STATIC_ASSERT(! is_sync_write_stream<sync_read_stream>::value);
BOOST_CORE_STATIC_ASSERT(! is_sync_stream<async_stream>::value);
BOOST_STATIC_ASSERT(has_get_executor<async_read_stream>::value);
BOOST_STATIC_ASSERT(has_get_executor<async_write_stream>::value);
BOOST_STATIC_ASSERT(has_get_executor<async_stream>::value);
BOOST_CORE_STATIC_ASSERT(has_get_executor<async_read_stream>::value);
BOOST_CORE_STATIC_ASSERT(has_get_executor<async_write_stream>::value);
BOOST_CORE_STATIC_ASSERT(has_get_executor<async_stream>::value);
BOOST_STATIC_ASSERT(! has_get_executor<sync_read_stream>::value);
BOOST_STATIC_ASSERT(! has_get_executor<sync_write_stream>::value);
BOOST_STATIC_ASSERT(! has_get_executor<sync_stream>::value);
BOOST_CORE_STATIC_ASSERT(! has_get_executor<sync_read_stream>::value);
BOOST_CORE_STATIC_ASSERT(! has_get_executor<sync_write_stream>::value);
BOOST_CORE_STATIC_ASSERT(! has_get_executor<sync_stream>::value);
BOOST_STATIC_ASSERT(is_async_read_stream<async_read_stream>::value);
BOOST_STATIC_ASSERT(is_async_read_stream<async_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_async_read_stream<async_read_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_async_read_stream<async_stream>::value);
#if BOOST_WORKAROUND(BOOST_MSVC, < 1910)
BOOST_STATIC_ASSERT(is_async_write_stream<net::ip::tcp::socket>::value);
BOOST_CORE_STATIC_ASSERT(is_async_write_stream<net::ip::tcp::socket>::value);
#else
BOOST_STATIC_ASSERT(is_async_write_stream<async_write_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_async_write_stream<async_write_stream>::value);
#endif
BOOST_STATIC_ASSERT(is_async_write_stream<async_stream>::value);
BOOST_STATIC_ASSERT(is_async_stream<async_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_async_write_stream<async_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_async_stream<async_stream>::value);
BOOST_STATIC_ASSERT(! is_async_write_stream<async_read_stream>::value);
BOOST_STATIC_ASSERT(! is_async_read_stream<async_write_stream>::value);
BOOST_STATIC_ASSERT(! is_async_stream<sync_stream>::value);
BOOST_CORE_STATIC_ASSERT(! is_async_write_stream<async_read_stream>::value);
BOOST_CORE_STATIC_ASSERT(! is_async_read_stream<async_write_stream>::value);
BOOST_CORE_STATIC_ASSERT(! is_async_stream<sync_stream>::value);
//--------------------------------------------------------------------------
@@ -306,13 +306,13 @@ public:
type layer(ioc);
layer.next_layer().open(net::ip::tcp::v4());
BEAST_EXPECT(layer.next_layer().is_open());
BOOST_STATIC_ASSERT(detail::has_next_layer<type>::value);
BOOST_STATIC_ASSERT((std::is_same<
BOOST_CORE_STATIC_ASSERT(detail::has_next_layer<type>::value);
BOOST_CORE_STATIC_ASSERT((std::is_same<
typename std::decay<decltype(get_lowest_layer(layer))>::type,
lowest_layer_type<decltype(layer)>>::value));
BOOST_STATIC_ASSERT(std::is_same<net::ip::tcp::socket&,
BOOST_CORE_STATIC_ASSERT(std::is_same<net::ip::tcp::socket&,
decltype(get_lowest_layer(layer))>::value);
BOOST_STATIC_ASSERT(std::is_same<net::ip::tcp::socket,
BOOST_CORE_STATIC_ASSERT(std::is_same<net::ip::tcp::socket,
lowest_layer_type<decltype(layer)>>::value);
close_socket(get_lowest_layer(layer));
BEAST_EXPECT(! layer.next_layer().is_open());
test/beast/core/test_buffer.hpp
+9 -9
View File
@@ -137,7 +137,7 @@ void
test_buffer_sequence(
ConstBufferSequence const& buffers)
{
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_const_buffer_sequence<
ConstBufferSequence>::value);
@@ -289,11 +289,11 @@ test_mutable_dynamic_buffer(
MutableDynamicBuffer_v0 const& b0,
std::true_type)
{
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_mutable_buffer_sequence<typename
MutableDynamicBuffer_v0::mutable_buffers_type>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_convertible<
typename MutableDynamicBuffer_v0::mutable_buffers_type,
typename MutableDynamicBuffer_v0::const_buffers_type>::value);
@@ -369,14 +369,14 @@ void
test_dynamic_buffer(
DynamicBuffer_v0 const& b0)
{
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_dynamic_buffer_v1<DynamicBuffer_v0>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_const_buffer_sequence<typename
DynamicBuffer_v0::const_buffers_type>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_mutable_buffer_sequence<typename
DynamicBuffer_v0::mutable_buffers_type>::value);
@@ -604,14 +604,14 @@ template<class DynamicBuffer_v0>
void
test_dynamic_buffer_ref(DynamicBuffer_v0 b0)
{
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_dynamic_buffer_v1<DynamicBuffer_v0>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_const_buffer_sequence<typename
DynamicBuffer_v0::const_buffers_type>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
net::is_mutable_buffer_sequence<typename
DynamicBuffer_v0::mutable_buffers_type>::value);
test/beast/core/test_handler.hpp
+1 -1
View File
@@ -97,7 +97,7 @@ public:
};
#if defined(BOOST_ASIO_NO_TS_EXECUTORS)
BOOST_STATIC_ASSERT(net::execution::is_executor<simple_executor>::value);
BOOST_CORE_STATIC_ASSERT(net::execution::is_executor<simple_executor>::value);
#endif
// A move-only handler
test/beast/http/chunk_encode.cpp
+2 -2
View File
@@ -30,10 +30,10 @@ class chunk_encode_test
public:
struct not_chunk_extensions {};
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
detail::is_chunk_extensions<chunk_extensions>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
! detail::is_chunk_extensions<not_chunk_extensions>::value);
template<class T, class... Args>
test/beast/http/empty_body.cpp
+3 -3
View File
@@ -16,9 +16,9 @@ namespace boost {
namespace beast {
namespace http {
BOOST_STATIC_ASSERT(is_body<empty_body>::value);
BOOST_STATIC_ASSERT(is_body_writer<empty_body>::value);
BOOST_STATIC_ASSERT(is_body_reader<empty_body>::value);
BOOST_CORE_STATIC_ASSERT(is_body<empty_body>::value);
BOOST_CORE_STATIC_ASSERT(is_body_writer<empty_body>::value);
BOOST_CORE_STATIC_ASSERT(is_body_reader<empty_body>::value);
} // http
} // beast
test/beast/http/fields.cpp
+30 -30
View File
@@ -28,12 +28,12 @@ public:
static constexpr std::size_t max_static_buffer =
sizeof(beast::detail::temporary_buffer);
BOOST_STATIC_ASSERT(is_fields<fields>::value);
BOOST_CORE_STATIC_ASSERT(is_fields<fields>::value);
// std::allocator is noexcept movable, fields should satisfy
// these constraints as well.
BOOST_STATIC_ASSERT(std::is_nothrow_move_constructible<fields>::value);
BOOST_STATIC_ASSERT(std::is_nothrow_move_assignable<fields>::value);
BOOST_CORE_STATIC_ASSERT(std::is_nothrow_move_constructible<fields>::value);
BOOST_CORE_STATIC_ASSERT(std::is_nothrow_move_assignable<fields>::value);
template<class Allocator>
using fa_t = basic_fields<Allocator>;
@@ -1039,33 +1039,33 @@ public:
void
testIssue2085()
{
BOOST_STATIC_ASSERT((! set_test<field, int>::value));
BOOST_STATIC_ASSERT((! set_test<field, std::nullptr_t>::value));
BOOST_STATIC_ASSERT((! set_test<field, double>::value));
BOOST_STATIC_ASSERT((! set_test<string_view, int>::value));
BOOST_STATIC_ASSERT((! set_test<string_view, std::nullptr_t>::value));
BOOST_STATIC_ASSERT((! set_test<string_view, double>::value));
BOOST_CORE_STATIC_ASSERT((! set_test<field, int>::value));
BOOST_CORE_STATIC_ASSERT((! set_test<field, std::nullptr_t>::value));
BOOST_CORE_STATIC_ASSERT((! set_test<field, double>::value));
BOOST_CORE_STATIC_ASSERT((! set_test<string_view, int>::value));
BOOST_CORE_STATIC_ASSERT((! set_test<string_view, std::nullptr_t>::value));
BOOST_CORE_STATIC_ASSERT((! set_test<string_view, double>::value));
BOOST_STATIC_ASSERT(( set_test<field, const char*>::value));
BOOST_STATIC_ASSERT(( set_test<field, string_view>::value));
BOOST_STATIC_ASSERT(( set_test<field, const char(&)[10]>::value));
BOOST_STATIC_ASSERT(( set_test<string_view, const char*>::value));
BOOST_STATIC_ASSERT(( set_test<string_view, string_view>::value));
BOOST_STATIC_ASSERT(( set_test<string_view, const char(&)[10]>::value));
BOOST_CORE_STATIC_ASSERT(( set_test<field, const char*>::value));
BOOST_CORE_STATIC_ASSERT(( set_test<field, string_view>::value));
BOOST_CORE_STATIC_ASSERT(( set_test<field, const char(&)[10]>::value));
BOOST_CORE_STATIC_ASSERT(( set_test<string_view, const char*>::value));
BOOST_CORE_STATIC_ASSERT(( set_test<string_view, string_view>::value));
BOOST_CORE_STATIC_ASSERT(( set_test<string_view, const char(&)[10]>::value));
BOOST_STATIC_ASSERT((! insert_test<field, int>::value));
BOOST_STATIC_ASSERT((! insert_test<field, std::nullptr_t>::value));
BOOST_STATIC_ASSERT((! insert_test<field, double>::value));
BOOST_STATIC_ASSERT((! insert_test<string_view, int>::value));
BOOST_STATIC_ASSERT((! insert_test<string_view, std::nullptr_t>::value));
BOOST_STATIC_ASSERT((! insert_test<string_view, double>::value));
BOOST_CORE_STATIC_ASSERT((! insert_test<field, int>::value));
BOOST_CORE_STATIC_ASSERT((! insert_test<field, std::nullptr_t>::value));
BOOST_CORE_STATIC_ASSERT((! insert_test<field, double>::value));
BOOST_CORE_STATIC_ASSERT((! insert_test<string_view, int>::value));
BOOST_CORE_STATIC_ASSERT((! insert_test<string_view, std::nullptr_t>::value));
BOOST_CORE_STATIC_ASSERT((! insert_test<string_view, double>::value));
BOOST_STATIC_ASSERT(( insert_test<field, const char*>::value));
BOOST_STATIC_ASSERT(( insert_test<field, string_view>::value));
BOOST_STATIC_ASSERT(( insert_test<field, const char(&)[10]>::value));
BOOST_STATIC_ASSERT(( insert_test<string_view, const char*>::value));
BOOST_STATIC_ASSERT(( insert_test<string_view, string_view>::value));
BOOST_STATIC_ASSERT(( insert_test<string_view, const char(&)[10]>::value));
BOOST_CORE_STATIC_ASSERT(( insert_test<field, const char*>::value));
BOOST_CORE_STATIC_ASSERT(( insert_test<field, string_view>::value));
BOOST_CORE_STATIC_ASSERT(( insert_test<field, const char(&)[10]>::value));
BOOST_CORE_STATIC_ASSERT(( insert_test<string_view, const char*>::value));
BOOST_CORE_STATIC_ASSERT(( insert_test<string_view, string_view>::value));
BOOST_CORE_STATIC_ASSERT(( insert_test<string_view, const char(&)[10]>::value));
}
template<class T>
@@ -1119,12 +1119,12 @@ public:
testIssue2517()
{
using test_fields = basic_fields<throwing_allocator<char>>;
BOOST_STATIC_ASSERT(is_fields<test_fields>::value);
BOOST_CORE_STATIC_ASSERT(is_fields<test_fields>::value);
// Check if basic_fields respects throw-constructibility and
// propagate_on_container_move_assignment of the allocator.
BOOST_STATIC_ASSERT(std::is_nothrow_move_constructible<test_fields>::value);
BOOST_STATIC_ASSERT(!std::is_nothrow_move_assignable<test_fields>::value);
BOOST_CORE_STATIC_ASSERT(std::is_nothrow_move_constructible<test_fields>::value);
BOOST_CORE_STATIC_ASSERT(!std::is_nothrow_move_assignable<test_fields>::value);
test_fields f1;
f1.insert("1", "1");
test/beast/http/message.cpp
+19 -19
View File
@@ -79,50 +79,50 @@ public:
};
// 0-arg
BOOST_STATIC_ASSERT(std::is_constructible<
BOOST_CORE_STATIC_ASSERT(std::is_constructible<
request<default_body>>::value);
// 1-arg
BOOST_STATIC_ASSERT(! std::is_constructible<request<one_arg_body>
BOOST_CORE_STATIC_ASSERT(! std::is_constructible<request<one_arg_body>
>::value);
//BOOST_STATIC_ASSERT(! std::is_constructible<request<one_arg_body>,
//BOOST_CORE_STATIC_ASSERT(! std::is_constructible<request<one_arg_body>,
// verb, string_view, unsigned>::value);
BOOST_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
BOOST_CORE_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
verb, string_view, unsigned, Arg1>::value);
BOOST_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
BOOST_CORE_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
verb, string_view, unsigned, Arg1&&>::value);
BOOST_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
BOOST_CORE_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
verb, string_view, unsigned, Arg1 const>::value);
BOOST_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
BOOST_CORE_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
verb, string_view, unsigned, Arg1 const&>::value);
// 1-arg + fields
BOOST_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
BOOST_CORE_STATIC_ASSERT(std::is_constructible<request<one_arg_body>,
verb, string_view, unsigned, Arg1, fields::allocator_type>::value);
BOOST_STATIC_ASSERT(std::is_constructible<request<one_arg_body>, std::piecewise_construct_t,
BOOST_CORE_STATIC_ASSERT(std::is_constructible<request<one_arg_body>, std::piecewise_construct_t,
std::tuple<Arg1>>::value);
BOOST_STATIC_ASSERT(std::is_constructible<request<two_arg_body>, std::piecewise_construct_t,
BOOST_CORE_STATIC_ASSERT(std::is_constructible<request<two_arg_body>, std::piecewise_construct_t,
std::tuple<Arg1, Arg2>>::value);
BOOST_STATIC_ASSERT(std::is_constructible<request<two_arg_body>, std::piecewise_construct_t,
BOOST_CORE_STATIC_ASSERT(std::is_constructible<request<two_arg_body>, std::piecewise_construct_t,
std::tuple<Arg1, Arg2>, std::tuple<fields::allocator_type>>::value);
// special members
BOOST_STATIC_ASSERT(std::is_copy_constructible<header<true>>::value);
BOOST_STATIC_ASSERT(std::is_move_constructible<header<true>>::value);
BOOST_STATIC_ASSERT(std::is_copy_assignable<header<true>>::value);
BOOST_STATIC_ASSERT(std::is_move_assignable<header<true>>::value);
BOOST_STATIC_ASSERT(std::is_copy_constructible<header<false>>::value);
BOOST_STATIC_ASSERT(std::is_move_constructible<header<false>>::value);
BOOST_STATIC_ASSERT(std::is_copy_assignable<header<false>>::value);
BOOST_STATIC_ASSERT(std::is_move_assignable<header<false>>::value);
BOOST_CORE_STATIC_ASSERT(std::is_copy_constructible<header<true>>::value);
BOOST_CORE_STATIC_ASSERT(std::is_move_constructible<header<true>>::value);
BOOST_CORE_STATIC_ASSERT(std::is_copy_assignable<header<true>>::value);
BOOST_CORE_STATIC_ASSERT(std::is_move_assignable<header<true>>::value);
BOOST_CORE_STATIC_ASSERT(std::is_copy_constructible<header<false>>::value);
BOOST_CORE_STATIC_ASSERT(std::is_move_constructible<header<false>>::value);
BOOST_CORE_STATIC_ASSERT(std::is_copy_assignable<header<false>>::value);
BOOST_CORE_STATIC_ASSERT(std::is_move_assignable<header<false>>::value);
void
testMessage()
test/beast/http/message_generator.cpp
+4 -4
View File
@@ -91,21 +91,21 @@ class message_generator_test : public beast::unit_test::suite
static_assert(
is_buffers_generator<message_generator>::value,
"buffers_generator not modeled");
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_constructible<
message_generator,
message<true, string_body>&&>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
std::is_constructible<
message_generator,
message<false, string_body>&&>::value);
// only rvalue refs
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
! std::is_constructible<
message_generator,
message<true, string_body>&>::value);
BOOST_STATIC_ASSERT(
BOOST_CORE_STATIC_ASSERT(
! std::is_constructible<
message_generator,
message<true, string_body> const&>::value);
test/beast/http/serializer.cpp
+6 -6
View File
@@ -61,25 +61,25 @@ public:
};
};
BOOST_STATIC_ASSERT(std::is_const< serializer<
BOOST_CORE_STATIC_ASSERT(std::is_const< serializer<
true, const_body>::value_type>::value);
BOOST_STATIC_ASSERT(! std::is_const<serializer<
BOOST_CORE_STATIC_ASSERT(! std::is_const<serializer<
true, mutable_body>::value_type>::value);
BOOST_STATIC_ASSERT(std::is_constructible<
BOOST_CORE_STATIC_ASSERT(std::is_constructible<
serializer<true, const_body>,
message <true, const_body>&>::value);
BOOST_STATIC_ASSERT(std::is_constructible<
BOOST_CORE_STATIC_ASSERT(std::is_constructible<
serializer<true, const_body>,
message <true, const_body> const&>::value);
BOOST_STATIC_ASSERT(std::is_constructible<
BOOST_CORE_STATIC_ASSERT(std::is_constructible<
serializer<true, mutable_body>,
message <true, mutable_body>&>::value);
BOOST_STATIC_ASSERT(! std::is_constructible<
BOOST_CORE_STATIC_ASSERT(! std::is_constructible<
serializer<true, mutable_body>,
message <true, mutable_body> const&>::value);
test/beast/http/string_body.cpp
+3 -3
View File
@@ -16,9 +16,9 @@ namespace boost {
namespace beast {
namespace http {
BOOST_STATIC_ASSERT(is_body<string_body>::value);
BOOST_STATIC_ASSERT(is_body_writer<string_body>::value);
BOOST_STATIC_ASSERT(is_body_reader<string_body>::value);
BOOST_CORE_STATIC_ASSERT(is_body<string_body>::value);
BOOST_CORE_STATIC_ASSERT(is_body_writer<string_body>::value);
BOOST_CORE_STATIC_ASSERT(is_body_reader<string_body>::value);
} // http
} // beast
test/beast/http/type_traits.cpp
+25 -25
View File
@@ -24,97 +24,97 @@ namespace http {
// Buffers
BOOST_STATIC_ASSERT(net::is_const_buffer_sequence<chunk_crlf>::value);
BOOST_CORE_STATIC_ASSERT(net::is_const_buffer_sequence<chunk_crlf>::value);
BOOST_STATIC_ASSERT(std::is_same<
BOOST_CORE_STATIC_ASSERT(std::is_same<
buffers_type<chunk_crlf>,
net::const_buffer>::value);
BOOST_STATIC_ASSERT(! std::is_same<
BOOST_CORE_STATIC_ASSERT(! std::is_same<
buffers_type<chunk_crlf>,
net::mutable_buffer>::value);
BOOST_STATIC_ASSERT(std::is_convertible<
BOOST_CORE_STATIC_ASSERT(std::is_convertible<
decltype(*net::buffer_sequence_begin(std::declval<chunk_crlf const&>())),
net::const_buffer
>::value);
BOOST_STATIC_ASSERT(! std::is_convertible<
BOOST_CORE_STATIC_ASSERT(! std::is_convertible<
decltype(*net::buffer_sequence_begin(std::declval<chunk_crlf const&>())),
net::mutable_buffer
>::value);
BOOST_STATIC_ASSERT(net::is_const_buffer_sequence<
BOOST_CORE_STATIC_ASSERT(net::is_const_buffer_sequence<
buffers_cat_view<net::const_buffer, chunk_crlf>
>::value);
BOOST_STATIC_ASSERT(std::is_same<
BOOST_CORE_STATIC_ASSERT(std::is_same<
buffers_type<buffers_cat_view<net::const_buffer, chunk_crlf>>,
net::const_buffer>::value);
BOOST_STATIC_ASSERT(! std::is_same<
BOOST_CORE_STATIC_ASSERT(! std::is_same<
buffers_type<buffers_cat_view<net::const_buffer, chunk_crlf>>,
net::mutable_buffer>::value);
using bs_t = buffers_suffix<buffers_cat_view<net::const_buffer, chunk_crlf>>;
BOOST_STATIC_ASSERT(std::is_same<
BOOST_CORE_STATIC_ASSERT(std::is_same<
buffers_type<bs_t>,
net::const_buffer>::value);
BOOST_STATIC_ASSERT(! std::is_same<
BOOST_CORE_STATIC_ASSERT(! std::is_same<
buffers_type<bs_t>,
net::mutable_buffer>::value);
BOOST_STATIC_ASSERT(std::is_convertible<
BOOST_CORE_STATIC_ASSERT(std::is_convertible<
decltype(*std::declval<bs_t const&>().begin()),
net::const_buffer>::value);
BOOST_STATIC_ASSERT(! std::is_convertible<
BOOST_CORE_STATIC_ASSERT(! std::is_convertible<
decltype(*std::declval<bs_t const&>().begin()),
net::mutable_buffer>::value);
BOOST_STATIC_ASSERT(std::is_same<
BOOST_CORE_STATIC_ASSERT(std::is_same<
buffers_iterator_type<bs_t>,
decltype(std::declval<bs_t const&>().begin())>::value);
using iter_t = bs_t::const_iterator;
BOOST_STATIC_ASSERT(std::is_same<
BOOST_CORE_STATIC_ASSERT(std::is_same<
net::const_buffer,
decltype(std::declval<iter_t const&>().operator*())
>::value);
BOOST_STATIC_ASSERT(! std::is_same<
BOOST_CORE_STATIC_ASSERT(! std::is_same<
net::mutable_buffer,
decltype(std::declval<iter_t const&>().operator*())
>::value);
BOOST_STATIC_ASSERT(std::is_constructible<
BOOST_CORE_STATIC_ASSERT(std::is_constructible<
net::const_buffer,
decltype(std::declval<iter_t const&>().operator*())>::value);
BOOST_STATIC_ASSERT(std::is_same<
BOOST_CORE_STATIC_ASSERT(std::is_same<
net::const_buffer, buffers_suffix<
buffers_cat_view<net::const_buffer, net::const_buffer, chunk_crlf>
>::const_iterator::value_type>::value);
BOOST_STATIC_ASSERT(std::is_same<
BOOST_CORE_STATIC_ASSERT(std::is_same<
net::const_buffer, buffers_type<
std::decay<buffers_cat_view<net::const_buffer, net::const_buffer, chunk_crlf>>::type
>>::value);
BOOST_STATIC_ASSERT(std::is_same<net::const_buffer, decltype(
BOOST_CORE_STATIC_ASSERT(std::is_same<net::const_buffer, decltype(
std::declval<buffers_suffix<buffers_cat_view<
net::const_buffer, net::const_buffer, chunk_crlf>
>::const_iterator const&>().operator*())>::value);
BOOST_STATIC_ASSERT(std::is_same<net::const_buffer, decltype(
BOOST_CORE_STATIC_ASSERT(std::is_same<net::const_buffer, decltype(
std::declval<buffers_suffix<buffers_cat_view<
net::const_buffer, net::const_buffer, chunk_crlf>
>::const_iterator const&>().operator*())>::value);
BOOST_STATIC_ASSERT(std::is_same<net::const_buffer, decltype(
BOOST_CORE_STATIC_ASSERT(std::is_same<net::const_buffer, decltype(
std::declval<buffers_suffix<
buffers_cat_view<
beast::detail::buffers_ref<buffers_cat_view<
@@ -138,11 +138,11 @@ BOOST_STATIC_ASSERT(std::is_same<net::const_buffer, decltype(
// Body
BOOST_STATIC_ASSERT(! is_body_writer<int>::value);
BOOST_CORE_STATIC_ASSERT(! is_body_writer<int>::value);
BOOST_STATIC_ASSERT(is_body_writer<empty_body>::value);
BOOST_CORE_STATIC_ASSERT(is_body_writer<empty_body>::value);
BOOST_STATIC_ASSERT(! is_body_reader<std::string>::value);
BOOST_CORE_STATIC_ASSERT(! is_body_reader<std::string>::value);
namespace {
@@ -150,7 +150,7 @@ struct not_fields {};
} // (anonymous)
BOOST_STATIC_ASSERT(! is_fields<not_fields>::value);
BOOST_CORE_STATIC_ASSERT(! is_fields<not_fields>::value);
} // http
} // beast
test/beast/http/vector_body.cpp
+6 -6
View File
@@ -18,14 +18,14 @@ namespace boost {
namespace beast {
namespace http {
BOOST_STATIC_ASSERT(is_body<vector_body<char>>::value);
BOOST_STATIC_ASSERT(is_body_writer<vector_body<char>>::value);
BOOST_STATIC_ASSERT(is_body_reader<vector_body<char>>::value);
BOOST_CORE_STATIC_ASSERT(is_body<vector_body<char>>::value);
BOOST_CORE_STATIC_ASSERT(is_body_writer<vector_body<char>>::value);
BOOST_CORE_STATIC_ASSERT(is_body_reader<vector_body<char>>::value);
#if __cpp_lib_byte >= 201603
BOOST_STATIC_ASSERT(is_body<vector_body<std::byte>>::value);
BOOST_STATIC_ASSERT(is_body_writer<vector_body<std::byte>>::value);
BOOST_STATIC_ASSERT(is_body_reader<vector_body<std::byte>>::value);
BOOST_CORE_STATIC_ASSERT(is_body<vector_body<std::byte>>::value);
BOOST_CORE_STATIC_ASSERT(is_body_writer<vector_body<std::byte>>::value);
BOOST_CORE_STATIC_ASSERT(is_body_reader<vector_body<std::byte>>::value);
#endif
} // http
test/beast/websocket/stream.cpp
+6 -6
View File
@@ -167,25 +167,25 @@ public:
void
run() override
{
BOOST_STATIC_ASSERT(std::is_constructible<
BOOST_CORE_STATIC_ASSERT(std::is_constructible<
stream<test::stream>, net::io_context&>::value);
BOOST_STATIC_ASSERT(std::is_move_constructible<
BOOST_CORE_STATIC_ASSERT(std::is_move_constructible<
stream<test::stream>>::value);
#if 0
BOOST_STATIC_ASSERT(std::is_move_assignable<
BOOST_CORE_STATIC_ASSERT(std::is_move_assignable<
stream<test::stream>>::value);
#endif
BOOST_STATIC_ASSERT(std::is_constructible<
BOOST_CORE_STATIC_ASSERT(std::is_constructible<
stream<test::stream&>, test::stream&>::value);
// VFALCO Should these be allowed for NextLayer references?
BOOST_STATIC_ASSERT(std::is_move_constructible<
BOOST_CORE_STATIC_ASSERT(std::is_move_constructible<
stream<test::stream&>>::value);
#if 0
BOOST_STATIC_ASSERT(std::is_move_assignable<
BOOST_CORE_STATIC_ASSERT(std::is_move_assignable<
stream<test::stream&>>::value);
#endif
test/beast/websocket/stream_base.cpp
+6 -6
View File
@@ -46,12 +46,12 @@ public:
void operator()();
};
BOOST_STATIC_ASSERT(detail::is_decorator<T1>::value);
BOOST_STATIC_ASSERT(detail::is_decorator<T2>::value);
BOOST_STATIC_ASSERT(detail::is_decorator<T3>::value);
BOOST_STATIC_ASSERT(detail::is_decorator<T4>::value);
BOOST_STATIC_ASSERT(! detail::is_decorator<T5>::value);
BOOST_STATIC_ASSERT(! detail::is_decorator<int>::value);
BOOST_CORE_STATIC_ASSERT(detail::is_decorator<T1>::value);
BOOST_CORE_STATIC_ASSERT(detail::is_decorator<T2>::value);
BOOST_CORE_STATIC_ASSERT(detail::is_decorator<T3>::value);
BOOST_CORE_STATIC_ASSERT(detail::is_decorator<T4>::value);
BOOST_CORE_STATIC_ASSERT(! detail::is_decorator<T5>::value);
BOOST_CORE_STATIC_ASSERT(! detail::is_decorator<int>::value);
void
testJavadoc()
test/cmake_test/CMakeLists.txt
+2 -2
View File
@@ -38,7 +38,6 @@ else()
optional
preprocessor
smart_ptr
static_assert
static_string
system
throw_exception
@@ -53,6 +52,7 @@ else()
date_time
move
describe
static_assert
utility
variant2
predef
@@ -75,8 +75,8 @@ else()
conversion
integer
detail
function_types
fusion
function_types
functional
typeof
)
test/doc/core_1_refresher.cpp
+2 -2
View File
@@ -202,8 +202,8 @@ std::size_t sync_write_stream::write_some(ConstBufferSequence const&, error_code
{
return 0;
}
BOOST_STATIC_ASSERT(is_sync_read_stream<sync_read_stream>::value);
BOOST_STATIC_ASSERT(is_sync_write_stream<sync_write_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_sync_read_stream<sync_read_stream>::value);
BOOST_CORE_STATIC_ASSERT(is_sync_write_stream<sync_write_stream>::value);
//------------------------------------------------------------------------------
test/doc/core_4_layers.cpp
+4 -4
View File
@@ -287,10 +287,10 @@ public:
template class counted_stream<test::stream>;
BOOST_STATIC_ASSERT(is_sync_read_stream<counted_stream<test::stream>>::value);
BOOST_STATIC_ASSERT(is_sync_write_stream<counted_stream<test::stream>>::value);
BOOST_STATIC_ASSERT(is_async_read_stream<counted_stream<test::stream>>::value);
BOOST_STATIC_ASSERT(is_async_write_stream<counted_stream<test::stream>>::value);
BOOST_CORE_STATIC_ASSERT(is_sync_read_stream<counted_stream<test::stream>>::value);
BOOST_CORE_STATIC_ASSERT(is_sync_write_stream<counted_stream<test::stream>>::value);
BOOST_CORE_STATIC_ASSERT(is_async_read_stream<counted_stream<test::stream>>::value);
BOOST_CORE_STATIC_ASSERT(is_async_write_stream<counted_stream<test::stream>>::value);
struct core_4_layers_test
: public beast::unit_test::suite