summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/src/tests/unit/buffer.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asio/src/tests/unit/buffer.cpp')
-rw-r--r--3rdparty/asio/src/tests/unit/buffer.cpp382
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)
)