diff options
Diffstat (limited to '3rdparty/asio/src/tests/unit/buffer.cpp')
-rw-r--r-- | 3rdparty/asio/src/tests/unit/buffer.cpp | 382 |
1 files changed, 364 insertions, 18 deletions
diff --git a/3rdparty/asio/src/tests/unit/buffer.cpp b/3rdparty/asio/src/tests/unit/buffer.cpp index b28533059ca..9fa1db6e67f 100644 --- a/3rdparty/asio/src/tests/unit/buffer.cpp +++ b/3rdparty/asio/src/tests/unit/buffer.cpp @@ -2,7 +2,7 @@ // buffer.cpp // ~~~~~~~~~~ // -// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -16,16 +16,14 @@ // Test that header file is self-contained. #include "asio/buffer.hpp" +#include <array> +#include <cstring> #include "unit_test.hpp" #if defined(ASIO_HAS_BOOST_ARRAY) # include <boost/array.hpp> #endif // defined(ASIO_HAS_BOOST_ARRAY) -#if defined(ASIO_HAS_STD_ARRAY) -# include <array> -#endif // defined(ASIO_HAS_STD_ARRAY) - //------------------------------------------------------------------------------ // buffer_compile test @@ -37,6 +35,42 @@ namespace buffer_compile { using namespace asio; +template <typename T> +class mutable_contiguous_container +{ +public: + typedef T value_type; + typedef T* iterator; + typedef const T* const_iterator; + typedef T& reference; + typedef const T& const_reference; + + mutable_contiguous_container() {} + std::size_t size() const { return 0; } + iterator begin() { return 0; } + const_iterator begin() const { return 0; } + iterator end() { return 0; } + const_iterator end() const { return 0; } +}; + +template <typename T> +class const_contiguous_container +{ +public: + typedef const T value_type; + typedef const T* iterator; + typedef const T* const_iterator; + typedef const T& reference; + typedef const T& const_reference; + + const_contiguous_container() {} + std::size_t size() const { return 0; } + iterator begin() { return 0; } + const_iterator begin() const { return 0; } + iterator end() { return 0; } + const_iterator end() const { return 0; } +}; + void test() { try @@ -50,11 +84,9 @@ void test() const boost::array<char, 1024>& const_array_data_1 = array_data; boost::array<const char, 1024> const_array_data_2 = { { 0 } }; #endif // defined(ASIO_HAS_BOOST_ARRAY) -#if defined(ASIO_HAS_STD_ARRAY) std::array<char, 1024> std_array_data; const std::array<char, 1024>& const_std_array_data_1 = std_array_data; std::array<const char, 1024> const_std_array_data_2 = { { 0 } }; -#endif // defined(ASIO_HAS_STD_ARRAY) std::vector<char> vector_data(1024); const std::vector<char>& const_vector_data = vector_data; std::string string_data(1024, ' '); @@ -62,18 +94,21 @@ void test() std::vector<mutable_buffer> mutable_buffer_sequence; std::vector<const_buffer> const_buffer_sequence; #if defined(ASIO_HAS_STD_STRING_VIEW) -# if defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) - std::experimental::string_view string_view_data(string_data); -# else // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) std::string_view string_view_data(string_data); -# endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) -#endif // defined(ASIO_HAS_STD_STRING_VIEW) +#elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) + std::experimental::string_view string_view_data(string_data); +#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) + mutable_contiguous_container<char> mutable_contiguous_data; + const mutable_contiguous_container<char> const_mutable_contiguous_data; + const_contiguous_container<char> const_contiguous_data; + const const_contiguous_container<char> const_const_contiguous_data; // mutable_buffer constructors. mutable_buffer mb1; mutable_buffer mb2(void_ptr_data, 1024); mutable_buffer mb3(mb1); + (void)mb3; // mutable_buffer functions. @@ -110,7 +145,9 @@ void test() const_buffer cb1; const_buffer cb2(const_void_ptr_data, 1024); const_buffer cb3(cb1); + (void)cb3; const_buffer cb4(mb1); + (void)cb4; // const_buffer functions. @@ -188,14 +225,12 @@ void test() cb1 = buffer(const_array_data_2); cb1 = buffer(const_array_data_2, 1024); #endif // defined(ASIO_HAS_BOOST_ARRAY) -#if defined(ASIO_HAS_STD_ARRAY) mb1 = buffer(std_array_data); mb1 = buffer(std_array_data, 1024); cb1 = buffer(const_std_array_data_1); cb1 = buffer(const_std_array_data_1, 1024); cb1 = buffer(const_std_array_data_2); cb1 = buffer(const_std_array_data_2, 1024); -#endif // defined(ASIO_HAS_STD_ARRAY) mb1 = buffer(vector_data); mb1 = buffer(vector_data, 1024); cb1 = buffer(const_vector_data); @@ -204,10 +239,18 @@ void test() mb1 = buffer(string_data, 1024); cb1 = buffer(const_string_data); cb1 = buffer(const_string_data, 1024); -#if defined(ASIO_HAS_STD_STRING_VIEW) +#if defined(ASIO_HAS_STRING_VIEW) cb1 = buffer(string_view_data); cb1 = buffer(string_view_data, 1024); -#endif // defined(ASIO_HAS_STD_STRING_VIEW) +#endif // defined(ASIO_HAS_STRING_VIEW) + mb1 = buffer(mutable_contiguous_data); + mb1 = buffer(mutable_contiguous_data, 1024); + cb1 = buffer(const_mutable_contiguous_data); + cb1 = buffer(const_mutable_contiguous_data, 1024); + cb1 = buffer(const_contiguous_data); + cb1 = buffer(const_contiguous_data, 1024); + cb1 = buffer(const_const_contiguous_data); + cb1 = buffer(const_const_contiguous_data, 1024); // buffer_copy function overloads. @@ -321,6 +364,7 @@ void test() std::size_t size40 = db3.max_size(); (void)size40; +#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1) dynamic_string_buffer<char, std::string::traits_type, std::string::allocator_type>::const_buffers_type cb5 = db1.data(); @@ -339,9 +383,35 @@ void test() db1.commit(1024); db3.commit(1024); +#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1) - db1.consume(1024); - db3.consume(1024); + dynamic_string_buffer<char, std::string::traits_type, + std::string::allocator_type>::mutable_buffers_type + mb7 = db1.data(0, 1); + (void)mb7; + dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type + mb8 = db3.data(0, 1); + (void)mb8; + + dynamic_string_buffer<char, std::string::traits_type, + std::string::allocator_type>::const_buffers_type + cb7 = static_cast<const dynamic_string_buffer<char, + std::string::traits_type, + std::string::allocator_type>&>(db1).data(0, 1); + (void)cb7; + dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type + cb8 = static_cast<const dynamic_vector_buffer<char, + std::allocator<char> >&>(db3).data(0, 1); + (void)cb8; + + db1.grow(1024); + db3.grow(1024); + + db1.shrink(1024); + db3.shrink(1024); + + db1.consume(0); + db3.consume(0); } catch (std::exception&) { @@ -559,9 +629,285 @@ void test() //------------------------------------------------------------------------------ +namespace buffer_sequence { + +using namespace asio; +using namespace std; + +struct valid_const_a +{ + typedef const_buffer* const_iterator; + typedef const_buffer value_type; + const_buffer* begin() const { return 0; } + const_buffer* end() const { return 0; } +}; + +struct valid_const_b +{ + const_buffer* begin() const { return 0; } + const_buffer* end() const { return 0; } +}; + +struct valid_mutable_a +{ + typedef mutable_buffer* const_iterator; + typedef mutable_buffer value_type; + mutable_buffer* begin() const { return 0; } + mutable_buffer* end() const { return 0; } +}; + +struct valid_mutable_b +{ + mutable_buffer* begin() const { return 0; } + mutable_buffer* end() const { return 0; } +}; + +struct invalid_const_a +{ + typedef int value_type; + int* begin() const { return 0; } + const_buffer* end() const { return 0; } +}; + +struct invalid_const_b +{ + typedef const_buffer value_type; + const_buffer* begin() const { return 0; } +}; + +struct invalid_const_c +{ + typedef const_buffer value_type; + const_buffer* end() const { return 0; } +}; + +struct invalid_const_d +{ + int* begin() const { return 0; } + const_buffer* end() const { return 0; } +}; + +struct invalid_const_e +{ + const_buffer* begin() const { return 0; } +}; + +struct invalid_const_f +{ + const_buffer* end() const { return 0; } +}; + +struct invalid_mutable_a +{ + typedef int value_type; + int* begin() const { return 0; } + mutable_buffer* end() const { return 0; } +}; + +struct invalid_mutable_b +{ + typedef mutable_buffer value_type; + mutable_buffer* begin() const { return 0; } +}; + +struct invalid_mutable_c +{ + typedef mutable_buffer value_type; + mutable_buffer* end() const { return 0; } +}; + +struct invalid_mutable_d +{ + int* begin() const { return 0; } + mutable_buffer* end() const { return 0; } +}; + +struct invalid_mutable_e +{ + mutable_buffer* begin() const { return 0; } +}; + +struct invalid_mutable_f +{ + mutable_buffer* end() const { return 0; } +}; + +void test() +{ + ASIO_CHECK(is_const_buffer_sequence<const_buffer>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<const_buffer>::value); + + const_buffer b1; + ASIO_CHECK(buffer_sequence_begin(b1) == &b1); + ASIO_CHECK(buffer_sequence_end(b1) == &b1 + 1); + + ASIO_CHECK(is_const_buffer_sequence<mutable_buffer>::value); + ASIO_CHECK(is_mutable_buffer_sequence<mutable_buffer>::value); + + mutable_buffer b2; + ASIO_CHECK(buffer_sequence_begin(b2) == &b2); + ASIO_CHECK(buffer_sequence_end(b2) == &b2 + 1); + +#if !defined(ASIO_NO_DEPRECATED) + ASIO_CHECK(is_const_buffer_sequence<const_buffers_1>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<const_buffers_1>::value); + + const_buffers_1 b3(0, 0); + ASIO_CHECK(buffer_sequence_begin(b3) == &b3); + ASIO_CHECK(buffer_sequence_end(b3) == &b3 + 1); + + ASIO_CHECK(is_const_buffer_sequence<mutable_buffers_1>::value); + ASIO_CHECK(is_mutable_buffer_sequence<mutable_buffers_1>::value); + + mutable_buffers_1 b4(0, 0); + ASIO_CHECK(buffer_sequence_begin(b4) == &b4); + ASIO_CHECK(buffer_sequence_end(b4) == &b4 + 1); +#endif // !defined(ASIO_NO_DEPRECATED) + + ASIO_CHECK(is_const_buffer_sequence<vector<const_buffer> >::value); + ASIO_CHECK(!is_mutable_buffer_sequence<vector<const_buffer> >::value); + + vector<const_buffer> b5; + ASIO_CHECK(buffer_sequence_begin(b5) == b5.begin()); + ASIO_CHECK(buffer_sequence_end(b5) == b5.end()); + + ASIO_CHECK(is_const_buffer_sequence<vector<mutable_buffer> >::value); + ASIO_CHECK(is_mutable_buffer_sequence<vector<mutable_buffer> >::value); + + vector<mutable_buffer> b6; + ASIO_CHECK(buffer_sequence_begin(b6) == b6.begin()); + ASIO_CHECK(buffer_sequence_end(b6) == b6.end()); + + ASIO_CHECK(is_const_buffer_sequence<valid_const_a>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<valid_const_a>::value); + + valid_const_a b7; + ASIO_CHECK(buffer_sequence_begin(b7) == b7.begin()); + ASIO_CHECK(buffer_sequence_end(b7) == b7.end()); + + ASIO_CHECK(is_const_buffer_sequence<valid_const_b>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<valid_const_b>::value); + + valid_const_b b8; + ASIO_CHECK(buffer_sequence_begin(b8) == b8.begin()); + ASIO_CHECK(buffer_sequence_end(b8) == b8.end()); + + ASIO_CHECK(is_const_buffer_sequence<valid_mutable_a>::value); + ASIO_CHECK(is_mutable_buffer_sequence<valid_mutable_a>::value); + + valid_mutable_a b9; + ASIO_CHECK(buffer_sequence_begin(b9) == b9.begin()); + ASIO_CHECK(buffer_sequence_end(b9) == b9.end()); + + ASIO_CHECK(is_const_buffer_sequence<valid_mutable_b>::value); + ASIO_CHECK(is_mutable_buffer_sequence<valid_mutable_b>::value); + + valid_mutable_b b10; + ASIO_CHECK(buffer_sequence_begin(b10) == b10.begin()); + ASIO_CHECK(buffer_sequence_end(b10) == b10.end()); + + ASIO_CHECK(!is_const_buffer_sequence<invalid_const_a>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_a>::value); + + ASIO_CHECK(!is_const_buffer_sequence<invalid_const_b>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_b>::value); + + ASIO_CHECK(!is_const_buffer_sequence<invalid_const_c>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_c>::value); + + ASIO_CHECK(!is_const_buffer_sequence<invalid_const_d>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_d>::value); + + ASIO_CHECK(!is_const_buffer_sequence<invalid_const_e>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_e>::value); + + ASIO_CHECK(!is_const_buffer_sequence<invalid_const_f>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_f>::value); + + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_a>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_a>::value); + + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_b>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_b>::value); + + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_c>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_c>::value); + + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_d>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_d>::value); + + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_e>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_e>::value); + + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_f>::value); + ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_f>::value); +} + +} // namespace buffer_sequence + +namespace buffer_literals { + +void test() +{ +#if defined(ASIO_HAS_USER_DEFINED_LITERALS) + using namespace asio::buffer_literals; + using namespace std; // For memcmp. + + asio::const_buffer b1 = ""_buf; + ASIO_CHECK(b1.size() == 0); + + asio::const_buffer b2 = "hello"_buf; + ASIO_CHECK(b2.size() == 5); + ASIO_CHECK(memcmp(b2.data(), "hello", 5) == 0); + + asio::const_buffer b3 = 0x00_buf; + ASIO_CHECK(b3.size() == 1); + ASIO_CHECK(memcmp(b3.data(), "\x00", 1) == 0); + + asio::const_buffer b4 = 0X01_buf; + ASIO_CHECK(b4.size() == 1); + ASIO_CHECK(memcmp(b4.data(), "\x01", 1) == 0); + + asio::const_buffer b5 = 0xaB_buf; + ASIO_CHECK(b5.size() == 1); + ASIO_CHECK(memcmp(b5.data(), "\xab", 1) == 0); + + asio::const_buffer b6 = 0xABcd_buf; + ASIO_CHECK(b6.size() == 2); + ASIO_CHECK(memcmp(b6.data(), "\xab\xcd", 2) == 0); + + asio::const_buffer b7 = 0x01ab01cd01ef01ba01dc01fe_buf; + ASIO_CHECK(b7.size() == 12); + ASIO_CHECK(memcmp(b7.data(), + "\x01\xab\x01\xcd\x01\xef\x01\xba\x01\xdc\x01\xfe", 12) == 0); + + asio::const_buffer b8 = 0b00000000_buf; + ASIO_CHECK(b8.size() == 1); + ASIO_CHECK(memcmp(b8.data(), "\x00", 1) == 0); + + asio::const_buffer b9 = 0B00000001_buf; + ASIO_CHECK(b9.size() == 1); + ASIO_CHECK(memcmp(b9.data(), "\x01", 1) == 0); + + asio::const_buffer b10 = 0B11111111_buf; + ASIO_CHECK(b10.size() == 1); + ASIO_CHECK(memcmp(b10.data(), "\xFF", 1) == 0); + + asio::const_buffer b11 = 0b1111000000001111_buf; + ASIO_CHECK(b11.size() == 2); + ASIO_CHECK(memcmp(b11.data(), "\xF0\x0F", 2) == 0); +#endif // (defined(ASIO_HAS_USER_DEFINED_LITERALS) +} + +} // namespace buffer_literals + +//------------------------------------------------------------------------------ + ASIO_TEST_SUITE ( "buffer", ASIO_COMPILE_TEST_CASE(buffer_compile::test) ASIO_TEST_CASE(buffer_copy_runtime::test) + ASIO_TEST_CASE(buffer_sequence::test) + ASIO_TEST_CASE(buffer_literals::test) ) |